fix: dict_del accepts any dict expression (not just variables); fix cache.omc inner-fn closures; add 13 cache lib tests

Author: RandomCoder-lab

examples/lib/cache.omc

@@ -6,8 +6,8 @@
 # Returns a wrapper that caches results keyed by stringified args.
 fn memoize(f) {
     h store = {}
-    fn memo_wrapper(arg) {
-        h key = to_str(arg)
+    h memo_wrapper = fn(arg) {
+        h key = to_string(arg)
         if dict_has(store, key) {
             return store[key]
         }
@@ -22,8 +22,8 @@ fn memoize(f) {
 # Two-argument version.
 fn memoize2(f) {
     h store = {}
-    fn memo2_wrapper(a, b) {
-        h key = str_concat(to_str(a), "|", to_str(b))
+    h memo2_wrapper = fn(a, b) {
+        h key = str_concat(to_string(a), "|", to_string(b))
         if dict_has(store, key) {
             return store[key]
         }
@@ -72,7 +72,7 @@ fn _lru_touch(lru, key) {
 
 # lru_get(lru, key) → value or null
 fn lru_get(lru, key) {
-    h k = to_str(key)
+    h k = to_string(key)
     if dict_has(lru["store"], k) {
         _lru_touch(lru, k)
         lru["hits"] = lru["hits"] + 1
@@ -84,8 +84,8 @@ fn lru_get(lru, key) {
 
 # lru_put(lru, key, value)
 fn lru_put(lru, key, value) {
-    h k = to_str(key)
-    if not dict_has(lru["store"], k) {
+    h k = to_string(key)
+    if !dict_has(lru["store"], k) {
         _lru_evict(lru)
         arr_push(lru["order"], k)
     } else {
@@ -112,8 +112,8 @@ fn lru_stats(lru) {
 # LRU-backed memoized wrapper.
 fn lru_memoize(f, capacity) {
     h cache = lru_new(capacity)
-    fn lru_wrapper(arg) {
-        h key = to_str(arg)
+    h lru_wrapper = fn(arg) {
+        h key = to_string(arg)
         h cached = lru_get(cache, key)
         if cached != null { return cached }
         h result = f(arg)
@@ -132,8 +132,8 @@ fn ttl_new(ttl_seconds) {
 
 # ttl_get(cache, key) → value or null (returns null if expired)
 fn ttl_get(cache, key) {
-    h k = to_str(key)
-    if not dict_has(cache["store"], k) {
+    h k = to_string(key)
+    if !dict_has(cache["store"], k) {
         cache["misses"] = cache["misses"] + 1
         return null
     }
@@ -150,7 +150,7 @@ fn ttl_get(cache, key) {
 
 # ttl_put(cache, key, value)
 fn ttl_put(cache, key, value) {
-    h k = to_str(key)
+    h k = to_string(key)
     h now = unix_time()
     cache["store"][k] = value
     cache["expires"][k] = now + cache["ttl"]
@@ -159,8 +159,8 @@ fn ttl_put(cache, key, value) {
 # ttl_memoize(fn, ttl_seconds) → fn
 fn ttl_memoize(f, ttl) {
     h cache = ttl_new(ttl)
-    fn ttl_wrapper(arg) {
-        h key = to_str(arg)
+    h ttl_wrapper = fn(arg) {
+        h key = to_string(arg)
         h cached = ttl_get(cache, key)
         if cached != null { return cached }
         h result = f(arg)
@@ -174,25 +174,24 @@ fn ttl_memoize(f, ttl) {
 
 # disk_cache_get(dir, key) → string or null
 fn disk_cache_get(dir, key) {
-    h safe_key = str_replace(to_str(key), "/", "_")
+    h safe_key = str_replace(to_string(key), "/", "_")
     h path = str_concat(dir, "/", safe_key, ".cache")
     h content = file_read(path)
-    if content == null { return null }
     return content
 }
 
 # disk_cache_put(dir, key, value)
 fn disk_cache_put(dir, key, value) {
-    h safe_key = str_replace(to_str(key), "/", "_")
+    h safe_key = str_replace(to_string(key), "/", "_")
     h path = str_concat(dir, "/", safe_key, ".cache")
-    file_write(path, to_str(value))
+    write_file(path, to_string(value))
 }
 
 # disk_memoize(fn, dir) → fn
 # Persists results to disk; survives process restarts.
 fn disk_memoize(f, dir) {
-    fn disk_wrapper(arg) {
-        h key = to_str(arg)
+    h disk_wrapper = fn(arg) {
+        h key = to_string(arg)
         h cached = disk_cache_get(dir, key)
         if cached != null { return cached }
         h result = f(arg)

examples/tests/test_cache_lib.omc

@@ -0,0 +1,129 @@
+# Tests for examples/lib/cache.omc
+# Uses module import to preserve internal helper functions.
+
+import "examples/lib/cache.omc" as cache
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn assert_true(cond, msg) { if !cond { test_record_failure(msg); } }
+fn assert_null(v, msg)    { if v != null { test_record_failure(msg + ": expected null, got " + to_string(v)); } }
+
+# ── memoize ──────────────────────────────────────────────────────────────────
+
+h _call_count = 0
+fn _expensive(n) {
+    _call_count = _call_count + 1
+    return n * n
+}
+
+fn test_memoize_computes_correctly() {
+    h m = cache.memoize(_expensive)
+    assert_eq(m(5), 25, "memoize 5^2")
+    assert_eq(m(7), 49, "memoize 7^2")
+}
+
+fn test_memoize_caches_second_call() {
+    _call_count = 0
+    h m = cache.memoize(_expensive)
+    m(4)
+    m(4)
+    m(4)
+    assert_eq(_call_count, 1, "fn called only once for same arg")
+}
+
+fn test_memoize_different_args_not_cached() {
+    _call_count = 0
+    h m = cache.memoize(_expensive)
+    m(1)
+    m(2)
+    m(3)
+    assert_eq(_call_count, 3, "distinct args → 3 calls")
+}
+
+fn test_memoize2_computes_correctly() {
+    fn _add(a, b) { return a + b }
+    h m = cache.memoize2(_add)
+    assert_eq(m(3, 4), 7, "memoize2 3+4")
+    assert_eq(m(10, 20), 30, "memoize2 10+20")
+}
+
+# ── LRU cache ─────────────────────────────────────────────────────────────────
+
+fn test_lru_basic_put_get() {
+    h lru = cache.lru_new(10)
+    cache.lru_put(lru, "x", 42)
+    assert_eq(cache.lru_get(lru, "x"), 42, "get after put")
+}
+
+fn test_lru_miss_returns_null() {
+    h lru = cache.lru_new(10)
+    assert_null(cache.lru_get(lru, "no_such_key"), "miss → null")
+}
+
+fn test_lru_evicts_when_full() {
+    h lru = cache.lru_new(3)
+    cache.lru_put(lru, "a", 1)
+    cache.lru_put(lru, "b", 2)
+    cache.lru_put(lru, "c", 3)
+    cache.lru_put(lru, "d", 4)
+    # oldest ("a") should be evicted (or "b" if "a" was touched)
+    h s = cache.lru_stats(lru)
+    assert_eq(s["size"], 3, "size stays at capacity")
+}
+
+fn test_lru_stats_hits_misses() {
+    h lru = cache.lru_new(10)
+    cache.lru_put(lru, "k", 99)
+    cache.lru_get(lru, "k")
+    cache.lru_get(lru, "k")
+    cache.lru_get(lru, "miss")
+    h s = cache.lru_stats(lru)
+    assert_eq(s["hits"],   2, "2 hits")
+    assert_eq(s["misses"], 1, "1 miss")
+}
+
+fn test_lru_memoize() {
+    h count = 0
+    fn _fn(n) { count = count + 1 return n * 3 }
+    h m = cache.lru_memoize(_fn, 5)
+    assert_eq(m(2), 6, "lru_memoize computes")
+    m(2)
+    m(2)
+    assert_eq(count, 1, "subsequent calls cached")
+}
+
+# ── TTL cache ─────────────────────────────────────────────────────────────────
+
+fn test_ttl_basic() {
+    h ttl = cache.ttl_new(3600)
+    cache.ttl_put(ttl, "k", "hello")
+    assert_eq(cache.ttl_get(ttl, "k"), "hello", "ttl get unexpired")
+}
+
+fn test_ttl_miss() {
+    h ttl = cache.ttl_new(3600)
+    assert_null(cache.ttl_get(ttl, "nope"), "ttl miss → null")
+}
+
+# ── batch_cached ──────────────────────────────────────────────────────────────
+
+fn test_batch_cached_results() {
+    fn _triple(n) { return n * 3 }
+    h bc = cache.lru_new(20)
+    h out = cache.batch_cached(_triple, [1, 2, 3], bc)
+    assert_eq(out[0], 3,  "batch[0]")
+    assert_eq(out[1], 6,  "batch[1]")
+    assert_eq(out[2], 9,  "batch[2]")
+}
+
+fn test_batch_cached_deduplicates() {
+    h fn_calls = 0
+    fn _inc(n) { fn_calls = fn_calls + 1 return n }
+    h bc = cache.lru_new(20)
+    cache.batch_cached(_inc, [1, 2, 1, 2, 1], bc)
+    assert_eq(fn_calls, 2, "only 2 unique keys computed")
+}

omnimcode-core/src/interpreter.rs

@@ -4804,16 +4804,19 @@ impl Interpreter {
             }
             "dict_del" => {
                 if args.len() < 2 {
-                    return Err("dict_del requires (dict_var, key)".to_string());
+                    return Err("dict_del requires (dict, key)".to_string());
                 }
                 let k = self.eval_expr(&args[1])?.to_display_string();
-                if let Expression::Variable(name) = &args[0] {
-                    if let Some(Value::Dict(d)) = self.get_var(name) {
+                // Accept both a plain variable AND any expression that evaluates
+                // to a dict (e.g. obj["store"]). The Rc is shared, so removal
+                // through the evaluated reference propagates to all holders.
+                match self.eval_expr(&args[0])? {
+                    Value::Dict(d) => {
                         d.borrow_mut().remove(&k);
-                        return Ok(Value::Null);
+                        Ok(Value::Null)
                     }
+                    _ => Err("dict_del: first argument must be a dict".to_string()),
                 }
-                Err("dict_del: first argument must be a dict variable".to_string())
             }
             "dict_keys" => {
                 if args.is_empty() {