Functions

cli/src/commands/eval.rs

@@ -57,6 +57,14 @@ pub fn eval_all<R: Read>(
             if asts.is_empty() {
                 return false;
             }
+            log::debug!(
+                "Expressions ({}):\n\t{}",
+                asts.len(),
+                asts.iter()
+                    .map(|ast| ast.print_expr())
+                    .collect::<Vec<_>>()
+                    .join("\n\t")
+            );
             'exprs: for (i, ast) in asts.iter().enumerate() {
                 let checked_ast = match checker.check_expr(ast) {
                     Ok(ast) => ast,

cli/src/commands/repl.rs

@@ -1,14 +1,14 @@
-use core::str;
-use std::io::{Read, Write};
-
+use crate::{commands::eval::eval_all, logger::init_logger_str, CLI_VERSION};
 use clap::{ArgMatches, Command};
 use colorful::Colorful;
+use core::str;
 use lento_core::{
     interpreter::env::global_env, lexer::lexer::InputSource, parser::parser, stdlib::init::stdlib,
     type_checker::checker::TypeChecker,
 };
+use std::io::{Read, Write};
 
-use crate::{commands::eval::eval_all, logger::init_logger_str, CLI_VERSION};
+const PROMPT: &str = "►";
 
 pub fn handle_command_repl(args: &ArgMatches, _arg_parser: &mut Command) {
     // Set the Ctrl-C handler to exit the program
@@ -51,7 +51,7 @@ pub fn handle_command_repl(args: &ArgMatches, _arg_parser: &mut Command) {
     let mut env = global_env();
     std.init_environment(&mut env);
     loop {
-        print!("> ");
+        print!("{} ", PROMPT);
         std::io::stdout().flush().unwrap();
         let found_expr = eval_all(
             &mut parser,

cli/src/error.rs

@@ -54,14 +54,6 @@ pub fn print_error_report(kind: &str, base: BaseError, content: &str, source: &I
         report = report.with_help(hint);
     }
 
-    if base.info.end.eof {
-        report = report.with_label(
-            Label::new((source.name(), base.info.end.index..base.info.end.index))
-                .with_message(format!("end of {}", source.human_readable()))
-                .with_color(ariadne::Color::Yellow),
-        );
-    }
-
     report
         .finish()
         .print((source.name(), Source::from(content)))

core/src/compiler/backends/cranelift/tests.rs

@@ -1,3 +1,4 @@
+/*
 #[cfg(test)]
 mod tests {
     use std::io::Write;
@@ -103,3 +104,4 @@ mod tests {
         assert!(!program_output.is_empty());
     }
 }
+*/

core/src/interpreter/eval.rs

@@ -2,11 +2,16 @@ use std::borrow::Borrow;
 
 use crate::{
     interpreter::value::NativeFunction,
+    parser::pattern::BindPattern,
     type_checker::{
-        checked_ast::{CheckedAst, CheckedBindPattern},
+        checked_ast::CheckedAst,
         types::{GetType, Type},
     },
-    util::{error::LineInfo, str::Str},
+    util::{
+        error::{BaseErrorExt, LineInfo},
+        failable::Failable,
+        str::Str,
+    },
 };
 
 use super::{
@@ -44,16 +49,11 @@ pub fn eval_expr(ast: &CheckedAst, env: &mut Environment) -> InterpretResult {
         CheckedAst::Identifier { name, .. } => match env.lookup_identifier(name) {
             (Some(v), _) => v.clone(),
             (_, Some(f)) => Value::Function(Box::new(f.clone())),
-            (_, _) => unreachable!("This should have been checked by the type checker"),
+            (_, _) => unreachable!("Undefined identifier: {}", name),
         },
         CheckedAst::Assignment { target, expr, .. } => {
-            let info = target.info();
-            let target = match target.to_owned() {
-                CheckedBindPattern::Variable { name, .. } => name,
-                _ => unreachable!("This should have been checked by the type checker"),
-            };
             let value = eval_expr(expr, env)?;
-            env.add_value(Str::String(target), value.clone(), info)?;
+            eval_assignment(target, &value, env)?;
             value
         }
         CheckedAst::List { exprs, ty, .. } => Value::List(
@@ -86,7 +86,7 @@ pub fn eval_expr(ast: &CheckedAst, env: &mut Environment) -> InterpretResult {
                 }
             }
         }
-        CheckedAst::FunctionDef {
+        CheckedAst::Lambda {
             param,
             body,
             return_type,
@@ -109,7 +109,7 @@ pub fn eval_expr(ast: &CheckedAst, env: &mut Environment) -> InterpretResult {
     if !matches!(ast, CheckedAst::Literal { .. }) {
         log::trace!(
             "Eval: {} -> {}",
-            ast.print_sexpr(),
+            ast.print_expr(),
             result.pretty_print_color()
         );
     }
@@ -160,7 +160,10 @@ fn eval_call(
             let arg = eval_expr(arg, env)?;
             let mut closure = env.new_child(Str::Str("<closure>"));
             // Bind the argument to the parameter of the function variation
-            closure.add_value(Str::String(param.name.clone()), arg.clone(), info)?;
+            let BindPattern::Variable { name, info } = &param.pattern else {
+                unreachable!("Other bind patterns are not supported yet");
+            };
+            closure.add_value(Str::String(name.clone()), arg.clone(), info)?;
             eval_expr(body, &mut closure)
         }
         Function::Native { .. } => {
@@ -216,3 +219,69 @@ fn eval_tuple(exprs: &[CheckedAst], env: &mut Environment) -> InterpretResult {
 
     Ok(Value::Tuple(values, Type::Tuple(types)))
 }
+
+/// Evaluate an assignment expression to a bind pattern
+fn eval_assignment(
+    pattern: &BindPattern,
+    value: &Value,
+    env: &mut Environment,
+) -> Failable<RuntimeError> {
+    match pattern {
+        // BindPattern::Function { name, params, .. } => {
+        //     let mut closure = env.new_child(Str::Str("<closure>"));
+        //     closure.add_value(name.clone(), value.clone(), pattern.info())?;
+        //     for param in params {
+        //         if let BindPattern::Variable { name, .. } = param {
+        //             closure.add_value(name.clone(), value.clone(), pattern.info())?;
+        //         }
+        //     }
+        // }
+        BindPattern::Variable { name, .. } => {
+            env.add_value(Str::String(name.clone()), value.clone(), pattern.info())?
+        }
+        BindPattern::Tuple { elements, .. } => {
+            let Value::Tuple(values, _) = value else {
+                unreachable!("This should have been checked by the type checker");
+            };
+            for (pattern, value) in elements.iter().zip(values) {
+                eval_assignment(pattern, value, env)?;
+            }
+        }
+        BindPattern::Record { fields, .. } => {
+            let Value::Record(values, _) = value else {
+                unreachable!("This should have been checked by the type checker");
+            };
+            for (key, pattern) in fields {
+                let Some((_, value)) = values.iter().find(|(k, _)| k == key) else {
+                    unreachable!("This should have been checked by the type checker");
+                };
+                eval_assignment(pattern, value, env)?;
+            }
+        }
+        BindPattern::List { elements, .. } => {
+            let Value::List(values, _) = value else {
+                unreachable!("This should have been checked by the type checker");
+            };
+            for (element, value) in elements.iter().zip(values) {
+                eval_assignment(element, value, env)?;
+            }
+        }
+        BindPattern::Wildcard => {}
+        BindPattern::Literal { value: lit, .. } => {
+            if *value != lit.as_value() {
+                return Err(RuntimeError::new(
+                    format!(
+                        "Literal pattern match failed: expected {}, found {}",
+                        lit.as_value().pretty_print(),
+                        value.pretty_print()
+                    ),
+                    pattern.info().clone(),
+                ));
+            }
+        }
+        BindPattern::Rest { .. } => {
+            // Handle rest pattern if needed
+        }
+    }
+    Ok(())
+}

core/src/interpreter/number.rs

@@ -69,7 +69,7 @@ trait NumberMethods {
 }
 
 /// An unsigned integer number type that can be represented in 1, 8, 16, 32, 64, 128 bits or arbitrary precision.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum UnsignedInteger {
     UInt1(u8), // Bit
     UInt8(u8), // Byte
@@ -525,7 +525,7 @@ impl ArithmeticOperations<UnsignedInteger> for UnsignedInteger {
 }
 
 /// A signed integer number type that can be represented in 8, 16, 32, 64, 128 bits or arbitrary precision.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum SignedInteger {
     Int8(i8),
     Int16(i16),