Add LambdaCollector and Intrinsic Lookup

2026-02-19 22:26:33 +01:00
parent 1b49719d31
commit 16d9d41e3d
2 changed files with 197 additions and 0 deletions
@@ -0,0 +1,108 @@
+use std::rc::Rc;
+use crate::ast::types::{Value, StaticType};
+
+/// Looks up a specialized intrinsic function for the given operator and argument types.
+/// Returns (Executable Value, Return Type) if a fast-path exists.
+pub fn lookup(name: &str, args: &[StaticType]) -> Option<(Value, StaticType)> {
+    match (name, args) {
+        // --- Integer Arithmetic ---
+        ("+", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Int(a + b)
+                } else {
+                    Value::Int(0) // Should not happen if type checker works
+                }
+            })),
+            StaticType::Int
+        )),
+        ("-", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Int(a - b)
+                } else {
+                    Value::Int(0)
+                }
+            })),
+            StaticType::Int
+        )),
+        ("-", [StaticType::Int, StaticType::Int, StaticType::Int]) => Some((
+             // Variadic optimization for 3 args (common in some Lisp dialects, though - usually is binary/unary)
+             // MyC's core.rs supports variadic subtraction.
+            Value::Function(Rc::new(|args| {
+                let a = match args[0] { Value::Int(i) => i, _ => 0 };
+                let b = match args[1] { Value::Int(i) => i, _ => 0 };
+                let c = match args[2] { Value::Int(i) => i, _ => 0 };
+                Value::Int(a - b - c)
+            })),
+            StaticType::Int
+        )),
+        ("*", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Int(a * b)
+                } else {
+                    Value::Int(0)
+                }
+            })),
+            StaticType::Int
+        )),
+        
+        // --- Integer Comparison ---
+        ("<=", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                 if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Bool(a <= b)
+                } else {
+                    Value::Bool(false)
+                }
+            })),
+            StaticType::Bool
+        )),
+        ("<", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                 if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Bool(a < b)
+                } else {
+                    Value::Bool(false)
+                }
+            })),
+            StaticType::Bool
+        )),
+         (">", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                 if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Bool(a > b)
+                } else {
+                    Value::Bool(false)
+                }
+            })),
+            StaticType::Bool
+        )),
+        (">=", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                 if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Bool(a >= b)
+                } else {
+                    Value::Bool(false)
+                }
+            })),
+            StaticType::Bool
+        )),
+        ("=", [StaticType::Int, StaticType::Int]) => Some((
+            Value::Function(Rc::new(|args| {
+                 if let (Value::Int(a), Value::Int(b)) = (&args[0], &args[1]) {
+                    Value::Bool(a == b)
+                } else {
+                    Value::Bool(false)
+                }
+            })),
+            StaticType::Bool
+        )),
+        
+        // --- Constant Unary for -1 (decrement optimization) ---
+        // Special case: tak uses (- x 1). The specializer sees Call("-", [Int, Int]).
+        
+        _ => None
+    }
+}