change lambda syntax from fn to \

crates/cli/tests/check/cant_reassign_captured_variable.nemo

@@ -1,6 +1,6 @@
 fn main() {
     let local = 10;
-    let assign_capture = fn () {
+    let assign_capture = \() {
         set local = 20;
     };
     {}

crates/cli/tests/check/lambda.nemo

@@ -1,5 +1,5 @@
 fn main() -> i32 {
-    let f = fn () -> f32 {
+    let f = \() -> i32 {
       return 10;
     };
     return 10.0;

crates/cli/tests/check/type_mismatch.nemo

@@ -1,2 +1,2 @@
 global x : i32 = 10.0
-global my_fn : fn (i32) -> i32 = fn (x : f32) -> f32 { x }
+global my_fn : fn (i32) -> i32 = \(x : f32) -> f32 { x }

crates/cli/tests/lib.rs

@@ -14,12 +14,9 @@ fn render_slash_path(path: &Utf8Path) -> String {
 
 fn compile_args(paths: &[Utf8PathBuf], out_name: &str) -> (Vec<String>, String) {
     let out_path = format!("tests/build/{}.wasm", out_name);
-    let mut args = vec![
-        "compile".to_string(),
-        "--output".to_string(),
-        out_path.clone(),
-    ];
+    let mut args = vec!["compile".to_string()];
     args.extend(paths.iter().map(|p| render_slash_path(p)));
+    args.extend(["--output".to_string(), out_path.clone()]);
     (args, out_path)
 }
 

crates/cli/tests/run/closures.nemo

@@ -1,16 +1,16 @@
 import log : fn (i32) -> unit from log
 
 fn main() {
-  let x = (fn (x : i32) -> i32 { x + 1 })(10);
+  let x = (\(x : i32) -> i32 { x + 1 })(10);
   log(x);
 
   let twice = {
-   fn (f : fn (i32) -> i32) -> fn(i32) -> i32 {
-     fn (x : i32) -> i32 {
+   \(f : fn (i32) -> i32) -> fn(i32) -> i32 {
+     \(x : i32) -> i32 {
        f(f(x))
      }
    }
   };
-  let add1 = fn (x : i32) -> i32 { x + 1 };
+  let add1 = \(x : i32) -> i32 { x + 1 };
   log(twice(add1)(3))
 }

crates/cli/tests/run/expr_postfix.nemo

@@ -14,7 +14,7 @@ fn f2(x : i32, y : i32) {
 }
 
 fn ff(x : i32) -> fn(i32) -> unit {
-  fn (y : i32) {
+  \(y : i32) {
     log(y)
   }
 }

crates/cli/tests/run/return.nemo

@@ -24,7 +24,7 @@ fn loop_return() -> f32 {
 }
 
 fn lambda_return() -> i32 {
-  let f = fn () -> bool {
+  let f = \() -> bool {
     return true;
   };
   if f() {

crates/cli/tests/snapshots/check@lambda.nemo.snap

@@ -5,19 +5,13 @@ info:
   args:
     - check
     - tests/check/lambda.nemo
+  env:
+    RUST_BACKTRACE: "0"
 input_file: crates/cli/tests/check/lambda.nemo
 ---
 success: false
 exit_code: 1
 ----- stdout -----
-[15] Error: Type mismatch. Expected f32, but got i32
-   ╭─[tests/check/lambda.nemo:1:13]
-   │
- 3 │       return 10;
-   │              ─┬  
-   │               ╰── Type mismatch. Expected f32, but got i32
-───╯
-
 [15] Error: Type mismatch. Expected i32, but got f32
    ╭─[tests/check/lambda.nemo:1:13]
    │
@@ -28,4 +22,4 @@ exit_code: 1
 
 
 ----- stderr -----
-Error: "Check failed with 2 errors"
+Error: "Check failed with 1 errors"

crates/cli/tests/snapshots/check@type_mismatch.nemo.snap

@@ -5,6 +5,8 @@ info:
   args:
     - check
     - tests/check/type_mismatch.nemo
+  env:
+    RUST_BACKTRACE: "0"
 input_file: crates/cli/tests/check/type_mismatch.nemo
 ---
 success: false
@@ -21,9 +23,9 @@ exit_code: 1
 [15] Error: Type mismatch. Expected fn (i32) -> i32, but got fn (f32) -> f32
    ╭─[tests/check/type_mismatch.nemo:1:13]
    │
- [38;5;246m2 │[0m [38;5;249mg[0m[38;5;249ml[0m[38;5;249mo[0m[38;5;249mb[0m[38;5;249ma[0m[38;5;249ml[0m[38;5;249m [0m[38;5;249mm[0m[38;5;249my[0m[38;5;249m_[0m[38;5;249mf[0m[38;5;249mn[0m[38;5;249m [0m[38;5;249m:[0m[38;5;249m [0m[38;5;249mf[0m[38;5;249mn[0m[38;5;249m [0m[38;5;249m([0m[38;5;249mi[0m[38;5;249m3[0m[38;5;249m2[0m[38;5;249m)[0m[38;5;249m [0m[38;5;249m-[0m[38;5;249m>[0m[38;5;249m [0m[38;5;249mi[0m[38;5;249m3[0m[38;5;249m2[0m[38;5;249m [0m[38;5;249m=[0m[38;5;249m [0mfn (x : f32) -> f32 { x }
- [38;5;240m  │[0m                                  ────────────┬────────────  
- [38;5;240m  │[0m                                              ╰────────────── Type mismatch. Expected fn (i32) -> i32, but got fn (f32) -> f32
+ [38;5;246m2 │[0m [38;5;249mg[0m[38;5;249ml[0m[38;5;249mo[0m[38;5;249mb[0m[38;5;249ma[0m[38;5;249ml[0m[38;5;249m [0m[38;5;249mm[0m[38;5;249my[0m[38;5;249m_[0m[38;5;249mf[0m[38;5;249mn[0m[38;5;249m [0m[38;5;249m:[0m[38;5;249m [0m[38;5;249mf[0m[38;5;249mn[0m[38;5;249m [0m[38;5;249m([0m[38;5;249mi[0m[38;5;249m3[0m[38;5;249m2[0m[38;5;249m)[0m[38;5;249m [0m[38;5;249m-[0m[38;5;249m>[0m[38;5;249m [0m[38;5;249mi[0m[38;5;249m3[0m[38;5;249m2[0m[38;5;249m [0m[38;5;249m=[0m[38;5;249m [0m\(x : f32) -> f32 { x }
+ [38;5;240m  │[0m                                  ───────────┬───────────  
+ [38;5;240m  │[0m                                             ╰───────────── Type mismatch. Expected fn (i32) -> i32, but got fn (f32) -> f32
 ───╯
 
 

crates/frontend/src/parser/grammar.rs

@@ -15,6 +15,12 @@ impl Progress {
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum TypAnnot {
+    Optional,
+    Required,
+}
+
 pub fn prog(p: &mut Parser) {
     while !p.at(SyntaxKind::EOF) {
         module(p);
@@ -197,7 +203,7 @@ fn top_func(p: &mut Parser) {
         p.error("expected a function name")
     }
     typ_param_list(p);
-    param_list(p);
+    param_list(p, TypAnnot::Required);
     if p.eat(T![->]) && !typ(p).made_progress() {
         p.error("expected a return type")
     }
@@ -225,15 +231,15 @@ fn typ_param_list(p: &mut Parser) -> Progress {
     Progress::Made
 }
 
-fn param_list(p: &mut Parser) {
+fn param_list(p: &mut Parser, typ_annot_opt: TypAnnot) {
     if !p.eat(SyntaxKind::L_PAREN) {
         p.error("expected a parameter list");
         return;
     }
     while p.at(SyntaxKind::IDENT) {
         let c = p.checkpoint();
         p.bump(SyntaxKind::IDENT);
-        if !typ_annot(p).made_progress() {
+        if !typ_annot(p).made_progress() && typ_annot_opt == TypAnnot::Required {
             p.error("expected a type annotation")
         }
         p.eat(SyntaxKind::COMMA);
@@ -428,8 +434,8 @@ fn expr(p: &mut Parser) -> Progress {
         match_expr(p);
         return Progress::Made;
     }
-    if p.at(T![fn]) {
-        func_expr(p);
+    if p.at(T![lambda]) {
+        lambda_expr(p);
         return Progress::Made;
     }
     if p.at(T![return]) {
@@ -537,10 +543,10 @@ fn return_expr(p: &mut Parser) {
     p.finish_at(c, SyntaxKind::EReturn)
 }
 
-fn func_expr(p: &mut Parser) {
+fn lambda_expr(p: &mut Parser) {
     let c = p.checkpoint();
-    p.bump(T![fn]);
-    param_list(p);
+    p.bump(T![lambda]);
+    param_list(p, TypAnnot::Optional);
     if p.eat(T![->]) && !typ(p).made_progress() {
         p.error("expected a return type")
     }

crates/frontend/src/parser/lexer.rs

@@ -229,6 +229,9 @@ pub enum SyntaxKind {
     #[token("/")]
     SLASH,
 
+    #[token("\\")]
+    BACKSLASH,
+
     #[token("=")]
     EQUALS,
 
@@ -449,6 +452,7 @@ macro_rules ! T {
     [exports] => { SyntaxKind::EXPORTS_KW };
     [use] => { SyntaxKind::USE_KW };
     [fn] => { SyntaxKind::FN_KW };
+    [lambda] => { SyntaxKind::BACKSLASH };
     [global] => { SyntaxKind::GLOBAL_KW };
     [import] => { SyntaxKind::IMPORT_KW };
     [from] => { SyntaxKind::FROM_KW };

crates/frontend/src/scip.rs

@@ -184,10 +184,13 @@ fn index_occurrence_map(
                     local_id: local_supply.to_string().into(),
                 };
                 let symbol = sym.to_string();
-                (sym, SymbolInformation {
-                    symbol,
-                    ..Default::default()
-                })
+                (
+                    sym,
+                    SymbolInformation {
+                        symbol,
+                        ..Default::default()
+                    },
+                )
             });
             if !sym.is_local() {
                 symbols.push(symbol_information.clone());

crates/frontend/src/syntax/nodes.rs

@@ -632,18 +632,9 @@ pub struct ELambda {
     pub(crate) syntax: SyntaxNode,
 }
 impl ELambda {
-    pub fn fn_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![fn])
-    }
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T!['('])
-    }
     pub fn params(&self) -> AstChildren<Param> {
         support::children(&self.syntax)
     }
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![')'])
-    }
     pub fn return_ty(&self) -> Option<Type> {
         support::child(&self.syntax)
     }

crates/frontend/src/syntax/nodes.ungram

@@ -107,7 +107,7 @@ EIf = 'if' condition:Expr then_branch:EBlock 'else' else_branch:EBlock
 EMatch = 'match' scrutinee:Expr '{' EMatchBranch* '}'
 EMatchBranch = Pattern '=>' body:EBlock
 
-ELambda = 'fn' '(' Param* ')' return_ty:Type body:Expr
+ELambda = Param* return_ty:Type body:Expr
 
 EBlock = '{' Declaration* '}'
 EReturn = 'return' Expr

design/lambdas.md

@@ -0,0 +1,20 @@
+# Anonymous functions (Lambdas)
+
+Lambdas are nameless functions that can appear in expression position. They
+capture variables from their environment. Value types are copied when captured
+and trying to `set` them results in a type error.
+
+They are defined using a `\` followed by a parameter list:
+
+```
+\(x : i32) -> i32 { x + 1 }
+```
+
+When a lambda appears in checking position its argument and result types
+can be ommitted and will be inferred.
+
+```
+let x : i32 = (\(y) { y + 1 })(2);
+```
+
+Lambdas are always monomorphic.