Renamed global let to def.

src/commands/tests.rs

@@ -4,12 +4,12 @@ use crate::commands::Arguments;
 use std::path::PathBuf;
 use std::process::Command;
 
-const TEST_SOURCE: &str = "let Nat = (A : Type) -> (A -> A) -> A -> A;
-let pow = (n : Nat) => (m : Nat) => (
+const TEST_SOURCE: &str = "def Nat = (A : Type) -> (A -> A) -> A -> A;
+def pow = (n : Nat) => (m : Nat) => (
     _ => n(_)(m(_))
 ) as Nat;
-let three = (A => f => a => f(f(f(a)))) as Nat;
-let nat_main = pow(three)(three);
+def three = (A => f => a => f(f(f(a)))) as Nat;
+def nat_main = pow(three)(three);
 ";
 
 #[test]

src/lexer.rs

@@ -13,8 +13,8 @@ mod token {
         Underscore,
         #[token("as")]
         As,
-        #[token("let")]
-        Let,
+        #[token("def")]
+        Define,
         #[token("Type")]
         Type,
         #[regex("[a-zA-Z_][a-zA-Z_0-9]*")]

src/parser.rs

@@ -16,7 +16,7 @@ pub mod cst {
     /// Represents the concrete syntax of a declaration.
     #[derive(Debug)]
     pub enum Declaration<'a> {
-        LetDeclaration {
+        Definition {
             name: &'a str,
             value: Expression<'a>,
         },
@@ -152,10 +152,10 @@ mod grammar {
                 = expr()
 
             rule decl() -> Declaration<'a>
-                = [Token::Let] [Token::Identifier(name)] [Token::Equals]
+                = [Token::Define] [Token::Identifier(name)] [Token::Equals]
                     value:expr() [Token::Semicolon]
                 {
-                    Declaration::LetDeclaration {
+                    Declaration::Definition {
                         name,
                         value
                     }

src/typing/abstraction.rs

@@ -162,7 +162,7 @@ pub fn abstract_file<'a>(file: &cst::File<'a>) -> Result<File<'a>, Vec<NameError
     for decl in &file.declarations {
         use cst::Declaration::*;
         match decl {
-            LetDeclaration { name, value } => {
+            Definition { name, value } => {
                 let expr = match abstract_expression(&globals, &Names::Empty, value) {
                     Ok(expr) => expr,
                     Err(mut errs) => {