- lazy parameters have been introduced.
- $IF has been added to the conditional directives, alongside the Declared() and Defined() special functions.
- Compound assignment operators +=, -=, *= and /= are now supported.
- Preparations for operator overloading.
Discussed recently, they’re an extra parameter passing call convention, alongside of var and const. A lazy parameter passes neither the value nor the reference, but the expression. That expression is lazily evaluated when the parameter is used in the procedure, and evaluated as often as it is used.
This allows to write conditional functions like the ternary operator (like Prism’s iif) without involving compiler magic, logging functions where the log expression to isn’t evaluated unless the log is active like discussed there, or all kind of purposes like that of lightweight anonymous functions, f.i.
procedure PrintNTimes(n : Integer; lazy s: String); begin while n>0 do begin Print(s); Dec(n); end; end; var i : Integer = 0; PrintNTimes(5, IntToStr(Inc(i))); // will print 12345
Implementation is still experimental, and units tests still limited, so more testing and issues reports are welcome 😉
Note that lazy parameters are currently available in the language, are implicit in internal “magic” functions, but aren’t available yet for functions declared via a TdwsUnit.
$IF, Declared() and Defined()
These functions have been introduced for conditional directives, but are also accessible in the code:
- in conditionals, they work on what is defined or declared during the compilation when the conditional is reached.
- in the code, they work on what is defined or declared at the end of the compilation.
$IF expressions have access to all constants defined up to the point where the $IF is located, as well as all stateless/invariant functions and operators operating on constants (f.i. you wished to, you could do hyperbolic sinus computation in a $IF, provided the parameter is from a constant expression).
Compound assignment operators
The +=, -=, *= and /= operators are now supported, but their use is at the moment only allowed on variables.
You can not use them on functions, properties, classes, or any other case where they could be made ambiguous by future language evolutions.
The limitation is introduced as they are planned to become first-class operators (as in C++), rather than just syntactical sugar or typing convenience like in C# or Freepascal. They’re intended to allow mutability.