Eiffel as an expression language
A functional-programming style, or more generally a style involving more expressions and fewer instructions, is possible in Eiffel. In particular, Eiffel’s agent mechanism embeds a full functional-programming mechanism in the object-oriented framework of the language.
To make the notations simpler, we are discussing and tentatively implementing a number of proposed extensions. They involve no fundamental new language mechanisms, but provide new, more concise notations for existing mechanisms. Examples are:
- Conditional expressions.
- Implicit tuple, a rule allowing the omission of brackets for an actual argument when it is a tuple and the last argument, e.g. f (x, y, z) as an abbreviation for f ([x, y, z]) (an example involving just one argument). Tuples already provided the equivalent of a variable-argument (“varargs”) facility, but it is made simpler to use with this convention.
- Parenthesis alias, making it possible to write just f (x, y) when f is an agent (closure, lambda expression, delegate etc. in other terminologies), i.e. treating f as if it were a function; the notation is simply an abbreviation for f.item ([x, y]) (an example that also takes advantage of implicit tuples). It has many other applications since a “parenthesis alias” can be defined for a feature of any class.
- Avoiding explicit assignments to Result.
- Type inference (to avoid explicitly specifying the type when it can be deduced from the context). This is a facility for the programmer, useful in particular for local variables, but does not affect the type system: Eiffel remains strongly typed, it is just that you can be lazy about writing the type when there is no ambiguity.
- In the same vein, omitting the entire list of generic parameters when it can be inferred.
The description of the mechanism (see the link in [1]) is in the form of a set of slides explaining the concepts and presenting example. This is a working document and feedback is welcome.
References
[1] Eiffel as an expression language, Eiffel Software working document, 2012-2014, see here.
Eiffel Software
Home page at ETH
Informatics Europe
LASER summer school
Propulsion Academy
Bertrand,
Has the updated type system been carefully written up or mechanized so that we can really understand what is going on with type inference?
Joe
Also, the link to the [1] URL seems to be missing.
Thanks, it is fixed now.
I quite like the parenthesis alias and implicit tuples.
I am not a big fan of the “else” keyword semantics overloading, but why not.
However, I have some real difficulty with the if-then-else expression. What is the type of such an expression? Do you automatically derive it from each expression branch? What about conversion? What if there are several possibilities?
Thanks