Allow binary operators to be used as lambdas (#385)

* Add operator lambdas

* Do not register anonymous functions as called functions

* Add tests

* Update CHANGELOG

* Update the docs

* Do not allow (..) to be used as a lambda

* Rename the function sum to any

CHANGELOG.md

@@ -11,6 +11,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ```
   [1, 2, 3] |> List.first |> Option.is_some  // Option.is_some(List.first([1, 2, 3]))
   ```
+- Allow binary operators to be used as lambdas
+  ```
+  function sum(l : list(int)) : int = foldl((+), 0, l)
+  function logical_and(x, y) = (&&)(x, y)
+  ```
 ### Changed
 - Error messages have been restructured (less newlines) to provide more unified errors. Also `pp_oneline/1` has been added.
 - Ban empty record definitions (e.g. `record r = {}` would give an error).

docs/sophia_syntax.md

@@ -200,6 +200,7 @@ switch(f(x))
 
 ```c
 Expr ::= '(' LamArgs ')' '=>' Block(Stmt)   // Anonymous function    (x) => x + 1
+       | '(' BinOp ')'                      // Operator lambda       (+)
        | 'if' '(' Expr ')' Expr 'else' Expr // If expression         if(x < y) y else x
        | Expr ':' Type                      // Type annotation       5 : int
        | Expr BinOp Expr                    // Binary operator       x + y

src/aeso_ast_infer_types.erl

@@ -1641,7 +1641,10 @@ infer_expr(Env, {app, Ann, Fun, Args0} = App) ->
             GeneralResultType = fresh_uvar(Ann),
             ResultType = fresh_uvar(Ann),
             when_warning(warn_unused_functions,
-                         fun() -> register_function_call(Namespace ++ qname(CurrentFun), Name) end),
+                         fun() -> if element(1, Name) == lam -> ok;
+                                     true -> register_function_call(Namespace ++ qname(CurrentFun), Name)
+                                  end
+                         end),
             unify(Env, FunType, {fun_t, [], NamedArgsVar, ArgTypes, GeneralResultType}, When),
             when_warning(warn_negative_spend, fun() -> warn_potential_negative_spend(Ann, NewFun1, NewArgs) end),
             add_constraint(

src/aeso_parser.erl

@@ -335,7 +335,7 @@ exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
+        [ id_or_addr(), con(), token(qid), token(qcon), binop_as_lam()
         , token(bytes), token(string), token(char)
         , token(int)
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
@@ -472,6 +472,19 @@ id()       -> token(id).
 tvar()     -> token(tvar).
 str()      -> token(string).
 
+binop_as_lam() ->
+    BinOps = ['&&', '||',
+              '+', '-', '*', '/', '^', 'mod',
+              '==', '!=', '<', '>', '<=', '=<', '>=',
+              '::', '++', '|>'],
+    OpToLam = fun(Op = {_, Ann}) ->
+                  IdL = {id, Ann, "l"},
+                  IdR = {id, Ann, "r"},
+                  Arg = fun(Id) -> {arg, Ann, Id, type_wildcard(Ann)} end,
+                  {lam, Ann, [Arg(IdL), Arg(IdR)], infix(IdL, Op, IdR)}
+              end,
+    ?RULE(parens(choice(lists:map(fun token/1, BinOps))), OpToLam(_1)).
+
 token(Tag) ->
     ?RULE(tok(Tag),
     case _1 of

test/aeso_compiler_tests.erl

@@ -795,6 +795,14 @@ failing_contracts() ->
                   [<<?Pos(2,5)
                      "Empty record definitions are not allowed. Cannot define the record `r`">>
                   ])
+    , ?TYPE_ERROR(operator_lambdas,
+                  [<<?Pos(9,32)
+                     "Cannot unify `(int, int) => int` and `(int) => 'a`\n"
+                     "when checking the application of\n"
+                     "  `(l : _, r : _) => l + r : (int, int) => int`\n"
+                     "to arguments\n"
+                     "  `1 : int`">>
+                  ])
     , ?TYPE_ERROR(warnings,
                   [<<?Pos(0, 0)
                       "The file `Triple.aes` is included but not used.">>,

test/contracts/operator_lambdas.aes

@@ -0,0 +1,14 @@
+include "List.aes"
+
+contract C =
+    type state = int
+
+    function any(l : list(bool)) : bool = List.foldl((||), false, l)
+
+    entrypoint init() =
+        let bad_application = (+)(1)
+        let good_application = (-)(3, 4)
+        let op_var = (+)
+        let op_var_application = op_var(3, 4)
+
+        good_application + op_var_application