Draft: Add Else Operator

src/cache/mod.rs

@@ -132,7 +132,7 @@ pub struct ModuleCache<'a> {
 
     pub file_cache: FileCache,
 
-    pub maybe_type: TypeInfoId,
+    pub maybe_type: Option<TypeInfoId>,
 }
 
 pub type FileCache = HashMap<PathBuf, String>;
@@ -419,7 +419,7 @@ impl<'a> ModuleCache<'a> {
             global_dependency_graph: DependencyGraph::default(),
             diagnostics: Vec::new(),
             error_count: 0,
-            maybe_type: TypeInfoId(0), // sentinel value
+            maybe_type: Some(TypeInfoId(0)), // sentinel value
             file_cache,
         }
     }

src/cranelift_backend/mod.rs

@@ -165,15 +165,15 @@ impl CodeGen for hir::If {
 
 impl CodeGen for hir::Else {
     fn codegen<'a>(&'a self, context: &mut Context<'a>, builder: &mut FunctionBuilder) -> Value {
-        let expr = builder.create_block();
-        let then_values = context.eval_all_in_block(&self.expr, expr, builder);
+        let lhs = builder.create_block();
+        let then_values = context.eval_all_in_block(&self.lhs, lhs, builder);
 
         let end = context.new_block_with_arg(&self.result_type, builder);
 
         let else_none = builder.create_block();
         builder.ins().jump(else_none, &[]);
 
-        let else_values = context.eval_all_in_block(&self.otherwise, else_none, builder);
+        let else_values = context.eval_all_in_block(&self.rhs, else_none, builder);
 
         if let Some(else_values) = else_values {
             builder.ins().jump(end, &else_values);
@@ -184,7 +184,7 @@ impl CodeGen for hir::Else {
         let end_values = builder.block_params(end);
         let ret = context.array_to_value(end_values, &self.result_type);
 
-        builder.seal_block(expr);
+        builder.seal_block(lhs);
         builder.seal_block(else_none);
         ret
     }

src/hir/closures.rs

@@ -91,8 +91,8 @@ fn replace_env(expr: Ast, env: &Ast, definition_id: hir::DefinitionId, f: &hir::
             Ast::If(if_expr)
         },
         Ast::Else(mut else_expr) => {
-            else_expr.expr = Box::new(replace_env(*else_expr.expr, env, definition_id, f));
-            else_expr.otherwise = Box::new(replace_env(*else_expr.otherwise, env, definition_id, f));
+            else_expr.lhs = Box::new(replace_env(*else_expr.lhs, env, definition_id, f));
+            else_expr.rhs = Box::new(replace_env(*else_expr.rhs, env, definition_id, f));
             Ast::Else(else_expr)
         },
         Ast::Sequence(mut seq) => {

src/hir/mod.rs

@@ -110,8 +110,8 @@ pub struct If {
 
 #[derive(Debug, Clone)]
 pub struct Else {
-    pub expr: Box<Ast>,
-    pub otherwise: Box<Ast>,
+    pub lhs: Box<Ast>,
+    pub rhs: Box<Ast>,
     pub result_type: Type,
 }
 

src/hir/monomorphisation.rs

@@ -1501,11 +1501,11 @@ impl<'c> Context<'c> {
     }
 
     fn monomorphise_else(&mut self, else_: &ast::Else<'c>) -> hir::Ast {
-        let expr = Box::new(self.monomorphise(&else_.expr));
-        let otherwise = Box::new(self.monomorphise(&else_.otherwise));
+        let lhs = Box::new(self.monomorphise(&else_.lhs));
+        let rhs = Box::new(self.monomorphise(&else_.rhs));
         let result_type = self.convert_type(else_.typ.as_ref().unwrap());
 
-        hir::Ast::Else(hir::Else { expr, otherwise, result_type })
+        hir::Ast::Else(hir::Else { lhs, rhs, result_type })
     }
 
     fn monomorphise_return(&mut self, return_: &ast::Return<'c>) -> hir::Ast {

src/hir/printer.rs

@@ -179,11 +179,11 @@ impl FmtAst for If {
 
 impl FmtAst for Else {
     fn fmt_ast(&self, printer: &mut AstPrinter, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Maybe a")?;
-        printer.block(self.expr.as_ref(), f)?;
-        write!(f, "else ")?;
-        printer.block(self.otherwise.as_ref(), f)?;
-        write!(f, " endelse")
+        write!(f, "(")?;
+        printer.block(self.lhs.as_ref(), f)?;
+        write!(f, " else ")?;
+        printer.block(self.rhs.as_ref(), f)?;
+        write!(f, ") ")
     }
 }
 

src/llvm/mod.rs

@@ -630,17 +630,15 @@ impl<'g> CodeGen<'g> for hir::If {
 impl<'g> CodeGen<'g> for hir::Else {
     fn codegen(&self, generator: &mut Generator<'g>) -> BasicValueEnum<'g> {
         let current_function = generator.current_function();
-        let expr_block = generator.context.append_basic_block(current_function, "expr");
         let end_block = generator.context.append_basic_block(current_function, "end_else");
 
         // Setup conditional jump
         let else_block = generator.context.append_basic_block(current_function, "else");
 
-        generator.builder.position_at_end(expr_block);
-        let (if_type, then_option) = generator.codegen_branch(&self.expr, end_block);
+        let (if_type, then_option) = generator.codegen_branch(&self.lhs, end_block);
 
         generator.builder.position_at_end(else_block);
-        let (_, else_option) = generator.codegen_branch(&self.otherwise, end_block);
+        let (_, else_option) = generator.codegen_branch(&self.rhs, end_block);
 
         // Create phi at the end of the if beforehand
         generator.builder.position_at_end(end_block);

src/nameresolution/builtin.rs

@@ -76,13 +76,11 @@ pub fn import_prelude(resolver: &mut NameResolver, cache: &mut ModuleCache<'_>)
         if let Some(id) = declare_module(&prelude_dir, cache, Location::builtin()) {
             let exports = define_module(id, cache, Location::builtin()).unwrap();
             resolver.current_scope().import(exports, cache, Location::builtin(), &HashSet::new());
+            let maybe_id = resolver.current_scope().types.get("Maybe").unwrap().clone();
+            cache.maybe_type = Some(maybe_id);
         }
     }
-    // Extract stdlib Types (specifically Maybe a) to keep track of for downstream
-    // sytantic sugaring
-    //println!("{:?}", resolver.current_scope().types);
-    let maybe_id = resolver.current_scope().types.get("Maybe").unwrap().clone();
-    cache.maybe_type = maybe_id;
+
     // Manually insert some builtins as if they were defined in the prelude
     resolver.current_scope().types.insert(Token::Comma.to_string(), PAIR_TYPE);
     resolver.current_scope().definitions.insert(Token::Comma.to_string(), PAIR_ID);

src/nameresolution/mod.rs

@@ -1069,10 +1069,10 @@ impl<'c> Resolvable<'c> for ast::Else<'c> {
     fn declare(&mut self, _resolver: &mut NameResolver, _cache: &mut ModuleCache<'c>) {}
 
     fn define(&mut self, resolver: &mut NameResolver, cache: &mut ModuleCache<'c>) {
-        self.expr.define(resolver, cache);
+        self.lhs.define(resolver, cache);
 
         resolver.push_scope(cache);
-        self.otherwise.define(resolver, cache);
+        self.rhs.define(resolver, cache);
         resolver.pop_scope(cache, true, None);
     }
 }

src/parser/ast.rs

@@ -175,8 +175,8 @@ pub struct If<'a> {
 // Maybe a then a else expression
 #[derive(Debug, Clone)]
 pub struct Else<'a> {
-    pub expr: Box<Ast<'a>>,
-    pub otherwise: Box<Ast<'a>>,
+    pub lhs: Box<Ast<'a>>,
+    pub rhs: Box<Ast<'a>>,
     pub location: Location<'a>,
     pub typ: Option<types::Type>,
 }
@@ -597,8 +597,8 @@ impl<'a> Ast<'a> {
         }
     }
 
-    pub fn else_expr(expr: Ast<'a>, otherwise: Ast<'a>, location: Location<'a>) -> Ast<'a> {
-        Ast::Else(Else { expr: Box::new(expr), otherwise: Box::new(otherwise), location, typ: None })
+    pub fn else_expr(lhs: Ast<'a>, rhs: Ast<'a>, location: Location<'a>) -> Ast<'a> {
+        Ast::Else(Else { lhs: Box::new(lhs), rhs: Box::new(rhs), location, typ: None })
     }
 
     pub fn definition(pattern: Ast<'a>, expr: Ast<'a>, location: Location<'a>) -> Ast<'a> {

src/parser/mod.rs

@@ -506,7 +506,7 @@ parser!(if_expr loc =
     _ !<- maybe_newline;
     _ !<- expect(Token::Then);
     then !<- block_or_statement;
-    otherwise !<- maybe(else_expr);
+    otherwise !<- maybe(without_else_expr);
     Ast::if_expr(condition, then, otherwise, loc)
 );
 
@@ -633,6 +633,14 @@ parser!(match_branch _loc -> 'b (Ast<'b>, Ast<'b>) =
     (pattern, branch)
 );
 
+parser!(without_else_expr _loc =
+    _ <- maybe_newline;
+    expr <- block_or_statement;
+    _ <- expect(Token::Else);
+    otherwise !<- block_or_statement;
+    otherwise
+);
+
 parser!(else_expr _loc =
     _ <- maybe_newline;
     expr <- block_or_statement;

src/parser/pretty_printer.rs

@@ -77,7 +77,7 @@ impl<'a> Display for ast::If<'a> {
 
 impl<'a> Display for ast::Else<'a> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "( {} else {})", self.expr, self.otherwise)
+        write!(f, "({} else {})", self.lhs, self.rhs)
     }
 }
 

src/types/typechecker.rs

@@ -1735,18 +1735,18 @@ impl<'a> Inferable<'a> for ast::Else<'a> {
         //let x = Type::TypeVariable(id);
         // Construct a Maybe x Type
         //let maybe_typeinfo_id = cache.type_infos.get(cache.maybe_type.0);
-        let maybe_type = UserDefined(cache.maybe_type);
+        let maybe_type = UserDefined(cache.maybe_type.expect("Maybe type should be befined from importing prelude"));
         let maybe_x = TypeApplication(Box::new(maybe_type), vec![x.clone()]);
         // Unify Maybe x with expr and raise if Type is mismatched
-        let mut expr = infer(self.expr.as_mut(), cache);
-        unify(&maybe_x, &mut expr.typ, self.expr.locate(), cache, TE::ElseBranchMismatch);
+        let mut lhs = infer(self.lhs.as_mut(), cache);
+        unify(&maybe_x, &mut lhs.typ, self.lhs.locate(), cache, TE::ElseBranchMismatch);
 
         // Unify x with a and raise if Type is mismatched
-        let mut otherwise = infer(self.otherwise.as_mut(), cache);
-        expr.combine(&mut otherwise, cache);
+        let mut rhs = infer(self.rhs.as_mut(), cache);
+        lhs.combine(&mut rhs, cache);
 
-        unify(&x, &otherwise.typ, self.location, cache, TE::ArgumentTypeMismatch);
-        expr.with_type(otherwise.typ)
+        unify(&x, &rhs.typ, self.location, cache, TE::ArgumentTypeMismatch);
+        lhs.with_type(rhs.typ)
     }
 }