Claude/add academic proofs mg s2z (#27)

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

src/ast/mod.rs

@@ -215,9 +215,14 @@ pub struct MatchArm {
 /// Pattern for matching
 #[derive(Debug, Clone)]
 pub enum Pattern {
+    /// Literal pattern: `42`, `"hello"`, `true`
     Literal(Literal),
+    /// Identifier pattern (binds value): `x`
     Identifier(String),
+    /// Wildcard pattern: `_`
     Wildcard,
+    /// Constructor pattern: `Okay(x)`, `Oops(e)`
+    Constructor(String, Option<Box<Pattern>>),
 }
 
 /// Expression types
@@ -239,6 +244,14 @@ pub enum Expr {
     GratitudeLiteral(String),
     /// Array literal
     Array(Vec<Spanned<Expr>>),
+    /// Index access: `arr[i]` or `str[i]`
+    Index(Box<Spanned<Expr>>, Box<Spanned<Expr>>),
+    /// Result success: `Okay(expr)`
+    Okay(Box<Spanned<Expr>>),
+    /// Result error: `Oops(expr)`
+    Oops(Box<Spanned<Expr>>),
+    /// Unwrap result: `expr?` or `unwrap(expr)`
+    Unwrap(Box<Spanned<Expr>>),
 }
 
 /// Binary operators

src/interpreter/mod.rs

@@ -294,10 +294,8 @@ impl Interpreter {
                 for arm in &decide.arms {
                     if self.pattern_matches(&arm.pattern, &scrutinee) {
                         self.env.push_scope();
-                        // Bind pattern variables
-                        if let Pattern::Identifier(name) = &arm.pattern {
-                            self.env.define(name.clone(), scrutinee.clone());
-                        }
+                        // Bind pattern variables (handles Identifier, Constructor, etc.)
+                        self.bind_pattern(&arm.pattern, &scrutinee);
                         for stmt in &arm.body {
                             if let ControlFlow::Return(v) = self.execute_statement(stmt)? {
                                 self.env.pop_scope();
@@ -353,6 +351,45 @@ impl Interpreter {
                 let lit_value = self.literal_to_value(lit);
                 value == &lit_value
             }
+            Pattern::Constructor(name, inner_pattern) => match (name.as_str(), value) {
+                ("Okay", Value::Okay(inner_val)) => {
+                    if let Some(pat) = inner_pattern {
+                        self.pattern_matches(pat, inner_val)
+                    } else {
+                        true
+                    }
+                }
+                ("Oops", Value::Oops(_)) => {
+                    // Oops pattern matches any Oops value
+                    // The inner pattern (if any) can bind the error message
+                    true
+                }
+                _ => false,
+            },
+        }
+    }
+
+    fn bind_pattern(&mut self, pattern: &Pattern, value: &Value) {
+        match pattern {
+            Pattern::Identifier(name) => {
+                self.env.define(name.clone(), value.clone());
+            }
+            Pattern::Constructor(name, inner_pattern) => {
+                if let Some(pat) = inner_pattern {
+                    match (name.as_str(), value) {
+                        ("Okay", Value::Okay(inner_val)) => {
+                            self.bind_pattern(pat, inner_val);
+                        }
+                        ("Oops", Value::Oops(err_msg)) => {
+                            self.bind_pattern(pat, &Value::String(err_msg.clone()));
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            Pattern::Wildcard | Pattern::Literal(_) => {
+                // No bindings for wildcards or literals
+            }
         }
     }
 
@@ -413,6 +450,57 @@ impl Interpreter {
                     .collect::<Result<_>>()?;
                 Ok(Value::Array(values))
             }
+            Expr::Index(target, index) => {
+                let target_val = self.evaluate(target)?;
+                let index_val = self.evaluate(index)?;
+                self.apply_index(target_val, index_val)
+            }
+            Expr::Okay(inner) => {
+                let val = self.evaluate(inner)?;
+                Ok(Value::Okay(Box::new(val)))
+            }
+            Expr::Oops(inner) => {
+                let val = self.evaluate(inner)?;
+                match val {
+                    Value::String(s) => Ok(Value::Oops(s)),
+                    other => Ok(Value::Oops(other.to_string())),
+                }
+            }
+            Expr::Unwrap(inner) => {
+                let val = self.evaluate(inner)?;
+                match val {
+                    Value::Okay(v) => Ok(*v),
+                    Value::Oops(e) => Err(RuntimeError::Complaint(e)),
+                    other => Ok(other), // Non-result values pass through
+                }
+            }
+        }
+    }
+
+    fn apply_index(&self, target: Value, index: Value) -> Result<Value> {
+        let idx = match index {
+            Value::Int(n) => {
+                if n < 0 {
+                    return Err(RuntimeError::IndexOutOfBounds(n as usize));
+                }
+                n as usize
+            }
+            _ => return Err(RuntimeError::TypeError("Index must be an integer".into())),
+        };
+
+        match target {
+            Value::Array(arr) => arr
+                .get(idx)
+                .cloned()
+                .ok_or(RuntimeError::IndexOutOfBounds(idx)),
+            Value::String(s) => s
+                .chars()
+                .nth(idx)
+                .map(|c| Value::String(c.to_string()))
+                .ok_or(RuntimeError::IndexOutOfBounds(idx)),
+            _ => Err(RuntimeError::TypeError(
+                "Cannot index this type".into(),
+            )),
         }
     }
 
@@ -469,6 +557,49 @@ impl Interpreter {
                     _ => Err(RuntimeError::TypeError("Cannot convert to Int".into())),
                 }
             }
+            "isOkay" => {
+                if args.len() != 1 {
+                    return Err(RuntimeError::ArityMismatch {
+                        expected: 1,
+                        got: args.len(),
+                    });
+                }
+                Ok(Some(Value::Bool(args[0].is_okay())))
+            }
+            "isOops" => {
+                if args.len() != 1 {
+                    return Err(RuntimeError::ArityMismatch {
+                        expected: 1,
+                        got: args.len(),
+                    });
+                }
+                Ok(Some(Value::Bool(args[0].is_oops())))
+            }
+            "unwrapOr" => {
+                if args.len() != 2 {
+                    return Err(RuntimeError::ArityMismatch {
+                        expected: 2,
+                        got: args.len(),
+                    });
+                }
+                match &args[0] {
+                    Value::Okay(v) => Ok(Some((**v).clone())),
+                    Value::Oops(_) => Ok(Some(args[1].clone())),
+                    other => Ok(Some(other.clone())),
+                }
+            }
+            "getError" => {
+                if args.len() != 1 {
+                    return Err(RuntimeError::ArityMismatch {
+                        expected: 1,
+                        got: args.len(),
+                    });
+                }
+                match &args[0] {
+                    Value::Oops(e) => Ok(Some(Value::String(e.clone()))),
+                    _ => Ok(Some(Value::Unit)),
+                }
+            }
             _ => Ok(None), // Not a builtin
         }
     }
@@ -678,4 +809,99 @@ mod tests {
         "#;
         assert!(run_program(source).is_ok());
     }
+
+    #[test]
+    fn test_result_okay() {
+        let source = r#"
+            to main() {
+                remember result = Okay(42);
+                remember is_ok = isOkay(result);
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
+
+    #[test]
+    fn test_result_oops() {
+        let source = r#"
+            to main() {
+                remember result = Oops("Something went wrong");
+                remember is_err = isOops(result);
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
+
+    #[test]
+    fn test_unwrap_or() {
+        let source = r#"
+            to main() {
+                remember ok_result = Okay(10);
+                remember err_result = Oops("error");
+                remember val1 = unwrapOr(ok_result, 0);
+                remember val2 = unwrapOr(err_result, 0);
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
+
+    #[test]
+    fn test_array_indexing() {
+        let source = r#"
+            to main() {
+                remember arr = [1, 2, 3, 4, 5];
+                remember first = arr[0];
+                remember third = arr[2];
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
+
+    #[test]
+    fn test_string_indexing() {
+        let source = r#"
+            to main() {
+                remember str = "hello";
+                remember first_char = str[0];
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
+
+    #[test]
+    fn test_decide_with_result() {
+        let source = r#"
+            to process(val: Int) -> Result {
+                when val > 0 {
+                    give back Okay(val * 2);
+                } otherwise {
+                    give back Oops("Value must be positive");
+                }
+            }
+
+            to main() {
+                remember result = process(5);
+                decide based on result {
+                    Okay(x) -> {
+                        print(x);
+                    }
+                    Oops(e) -> {
+                        print(e);
+                    }
+                }
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
+
+    #[test]
+    fn test_chained_indexing() {
+        let source = r#"
+            to main() {
+                remember matrix = [[1, 2], [3, 4]];
+                remember val = matrix[0][1];
+            }
+        "#;
+        assert!(run_program(source).is_ok());
+    }
 }

src/interpreter/value.rs

@@ -9,6 +9,10 @@ pub enum Value {
     Bool(bool),
     Array(Vec<Value>),
     Unit,
+    /// Result success: `Okay(value)`
+    Okay(Box<Value>),
+    /// Result error: `Oops(message)`
+    Oops(String),
 }
 
 impl Value {
@@ -21,6 +25,27 @@ impl Value {
             Value::String(s) => !s.is_empty(),
             Value::Array(a) => !a.is_empty(),
             Value::Unit => false,
+            Value::Okay(_) => true,
+            Value::Oops(_) => false,
+        }
+    }
+
+    /// Check if this is an Okay result
+    pub fn is_okay(&self) -> bool {
+        matches!(self, Value::Okay(_))
+    }
+
+    /// Check if this is an Oops result
+    pub fn is_oops(&self) -> bool {
+        matches!(self, Value::Oops(_))
+    }
+
+    /// Unwrap an Okay value, or return the error
+    pub fn unwrap(self) -> Result<Value, String> {
+        match self {
+            Value::Okay(v) => Ok(*v),
+            Value::Oops(e) => Err(e),
+            other => Ok(other), // Non-result values pass through
         }
     }
 }
@@ -43,6 +68,8 @@ impl fmt::Display for Value {
                 write!(f, "]")
             }
             Value::Unit => write!(f, "()"),
+            Value::Okay(v) => write!(f, "Okay({})", v),
+            Value::Oops(e) => write!(f, "Oops(\"{}\")", e),
         }
     }
 }