At some point, the new version of Resharper supported Lambda functions and turned all my beautiful and readable code into single LINQ expressions. That project didn't end well...
Of course, just because you can, doesn't mean you should. One great example with this I have is I worked on code with someone who really did not like multiple ifs and started building multiline boolean expressions to cover to the point where when had a bug in one of these conditions, it lead to having to rewrite nearly all of them and took multiple hours to do so.
But of course the language can also limit such features, e.g. what I really like about python, as opposed to for example Javascript (or C#, C++ and most other languages) is that it limits lambda functions to single expressions. While you have in Javascript often whole functions of multiple lines, with conditions, loops, etc as lambdas (well from a theoretical viewpoint those aren't lambda expressions anymore but anonymous functions), python only allow a singe expression:
Everything more than that, you need to write a function. Which I think is a great limitation, and one reason why monster lambda constructs aren't a thing in Python while in Javascript they make up most of the javascript code you see.
Also the features need to fit the language. For example I really like the way swift implements optionals is great, but would not be possible in Pascal as Pascal uses Pointers.
But a few features I like greatly and I think would fit pascal would be:
1. Dynamic sets and dictionaries (additionally to the dynamic arrays which already exist) as in Python or Swift, making dictionaries (or associative arrays as they are also often called) a "base type" like dynamic arrays are with assignment syntax (such as [key: value, ...]), would make a lot of code much easier than having to initilize and fill a Dictionary object. Same vor hashsets (in addition to the already existing bitsets)
2. List comprehensions, like in Haskell or python, where you can create a list from expressions like squares = [x*x for x in 0..10]
3. named function parameters as in python, so you can write funcname(param1: Value, param2: Value, ...), which would be great for functions taking many parameters, which currently can be a massive source of errors when using default parameter values (where you do not realize you miss an argument because your arguments are shifted by 1 after adding a new argument in the front)
4. Fixing function parameters, like in haskell, where the function parameters can be partly set (like where (plus 5) is a function that calls plus with the first argument being 5). This would basically be possible (even if it's tedious as it requires declaring every parameter) with lambads.
5. Operators as functions, as in haskell. In Haskell you can take any operator also as function where (+) is the function taking two inputs calling the + operator on them. This is really useful if you want to pass a function pointer but you want it to only execute a simple operator, e.g. if you have a sorted list class that takes a compare function pointer and you could simply pass the existing < operator for integers.
6. Tuples like in Python or C#, just allowing functions to return more than one value as result, so you do not need to have to use an out parameter (which if you want to ignore it requires you to declare a dummy variable)
These are just 6 examples that I think would not just be really useful, but could also fit the language without leading to a massive feature bloat, as these would integrate nicely with already established features of the language