gh-53: Add SELF.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -192,6 +192,8 @@
 - `<"foo" = 1, "bar" = 10>` is a 1-level map with string keys.
 - `<"outer" = <"inner" = 1>, "other" = 0>` nests a map value under key `"outer"`.
 
+A special literal `SELF` is recognized inside map literals. When used as a value within a map literal, `SELF` denotes a pointer (alias) to the enclosing `MAP` being constructed; storing `SELF` creates an entry that references the map itself so mutations via that reference affect the same map instance.
+
 Map indexing uses angle brackets and a comma-separated key list: `m<k1>` or `m<k1,k2>` to lookup nested values. Keys MUST be scalar values of type `INT`, `FLT`, or `STR` (tensor values are not permitted as keys). The number of keys supplied MAY vary between lookups and different keys need not share the same depth: maps are sparse and do not require rectangular shapes.
 
 Maps preserve insertion order: keys are stored in the order they are inserted (left-to-right for keys written in a literal and in the order of creation for keys added later). Iteration and serialized representations of a map reflect this insertion order.

src/builtins.c

@@ -3502,8 +3502,44 @@ static Value builtin_lcm(Interpreter* interp, Value* args, int argc, Expr** arg_
 
 // ============ Comparison operators ============
 
-// Recursive deep equality helper for Values (returns 1 if equal, 0 otherwise)
-static int value_deep_eq(Value a, Value b) {
+typedef struct {
+    const void* a;
+    const void* b;
+    ValueType type;
+} EqSeenPair;
+
+typedef struct {
+    EqSeenPair* items;
+    size_t count;
+    size_t cap;
+} EqSeenSet;
+
+static int eq_seen_contains(EqSeenSet* seen, const void* a, const void* b, ValueType type) {
+    if (!seen) return 0;
+    for (size_t i = 0; i < seen->count; i++) {
+        EqSeenPair* p = &seen->items[i];
+        if (p->type != type) continue;
+        if ((p->a == a && p->b == b) || (p->a == b && p->b == a)) return 1;
+    }
+    return 0;
+}
+
+static void eq_seen_add(EqSeenSet* seen, const void* a, const void* b, ValueType type) {
+    if (!seen) return;
+    if (seen->count + 1 > seen->cap) {
+        size_t new_cap = seen->cap == 0 ? 16 : seen->cap * 2;
+        EqSeenPair* grown = realloc(seen->items, sizeof(EqSeenPair) * new_cap);
+        if (!grown) { fprintf(stderr, "Out of memory\n"); exit(1); }
+        seen->items = grown;
+        seen->cap = new_cap;
+    }
+    seen->items[seen->count].a = a;
+    seen->items[seen->count].b = b;
+    seen->items[seen->count].type = type;
+    seen->count++;
+}
+
+static int value_deep_eq_impl(Value a, Value b, EqSeenSet* seen) {
     if (a.type != b.type) return 0;
     switch (a.type) {
         case VAL_INT:
@@ -3519,27 +3555,33 @@ static int value_deep_eq(Value a, Value b) {
             Tensor* ta = a.as.tns;
             Tensor* tb = b.as.tns;
             if (ta == NULL || tb == NULL) return (ta == tb) ? 1 : 0;
+            if (ta == tb) return 1;
+            if (eq_seen_contains(seen, ta, tb, VAL_TNS)) return 1;
+            eq_seen_add(seen, ta, tb, VAL_TNS);
             if (ta->elem_type != tb->elem_type) return 0;
             if (ta->ndim != tb->ndim) return 0;
             for (size_t i = 0; i < ta->ndim; i++) {
                 if (ta->shape[i] != tb->shape[i]) return 0;
             }
             if (ta->length != tb->length) return 0;
             for (size_t i = 0; i < ta->length; i++) {
-                if (!value_deep_eq(ta->data[i], tb->data[i])) return 0;
+                if (!value_deep_eq_impl(ta->data[i], tb->data[i], seen)) return 0;
             }
             return 1;
         }
         case VAL_MAP: {
             Map* ma = a.as.map;
             Map* mb = b.as.map;
             if (ma == NULL || mb == NULL) return (ma == mb) ? 1 : 0;
+            if (ma == mb) return 1;
+            if (eq_seen_contains(seen, ma, mb, VAL_MAP)) return 1;
+            eq_seen_add(seen, ma, mb, VAL_MAP);
             if (ma->count != mb->count) return 0;
             for (size_t i = 0; i < ma->count; i++) {
                 int found = 0;
                 for (size_t j = 0; j < mb->count; j++) {
-                    if (value_deep_eq(ma->items[i].key, mb->items[j].key)) {
-                        if (!value_deep_eq(ma->items[i].value, mb->items[j].value)) return 0;
+                    if (value_deep_eq_impl(ma->items[i].key, mb->items[j].key, seen)) {
+                        if (!value_deep_eq_impl(ma->items[i].value, mb->items[j].value, seen)) return 0;
                         found = 1;
                         break;
                     }
@@ -3555,6 +3597,14 @@ static int value_deep_eq(Value a, Value b) {
     }
 }
 
+// Recursive deep equality helper for Values (returns 1 if equal, 0 otherwise)
+static int value_deep_eq(Value a, Value b) {
+    EqSeenSet seen = {0};
+    int out = value_deep_eq_impl(a, b, &seen);
+    free(seen.items);
+    return out;
+}
+
 static Value builtin_eq(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
     (void)arg_nodes; (void)env; (void)interp;
 

src/interpreter.c

@@ -1406,11 +1406,53 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
                     interp->error_col = expr->column;
                     return value_null();
                 }
-                Value v = eval_expr(interp, vexpr, env);
-                if (interp->error) { value_free(k); value_free(mv); return value_null(); }
-                value_map_set(&mv, k, v);
-                value_free(k);
-                value_free(v);
+                // Special-cases for SELF usage inside map literal:
+                // - `SELF` as a bare identifier -> alias pointing to enclosing map
+                // - `SELF<...>` -> lookup into the enclosing map using the provided key(s)
+                if (vexpr->type == EXPR_IDENT && vexpr->as.ident && strcmp(vexpr->as.ident, "SELF") == 0) {
+                    value_map_set_self(&mv, k);
+                    value_free(k);
+                } else if (vexpr->type == EXPR_INDEX && vexpr->as.index.target && vexpr->as.index.target->type == EXPR_IDENT
+                           && vexpr->as.index.target->as.ident && strcmp(vexpr->as.index.target->as.ident, "SELF") == 0) {
+                    // Evaluate index key(s) and perform lookup on the partially-constructed map `mv`.
+                    ExprList* idxs = &vexpr->as.index.indices;
+                    // Only single-key lookup is supported here (map keys are scalars). If multiple indices provided,
+                    // resolve nested map access by descending.
+                    Value cur = value_copy(mv);
+                    bool err = false;
+                    Value final_val = value_null();
+                    for (size_t ii = 0; ii < idxs->count; ii++) {
+                        Expr* ik = idxs->items[ii];
+                        Value ikv = eval_expr(interp, ik, env);
+                        if (interp->error) { value_free(ikv); value_free(cur); err = true; break; }
+                        if (!(ikv.type == VAL_INT || ikv.type == VAL_STR || ikv.type == VAL_FLT)) {
+                            value_free(ikv); value_free(cur);
+                            interp->error = strdup("Map index must be INT, FLT or STR");
+                            interp->error_line = ik->line;
+                            interp->error_col = ik->column;
+                            err = true; break;
+                        }
+                        int found = 0;
+                        Value got = value_map_get(cur, ikv, &found);
+                        value_free(ikv);
+                        if (!found) { value_free(cur); final_val = value_null(); break; }
+                        value_free(cur);
+                        cur = got; // continue descending (got is a copy)
+                        if (ii + 1 == idxs->count) final_val = value_copy(cur);
+                    }
+                    if (err) { value_free(k); value_free(mv); return value_null(); }
+                    // final_val holds the value to insert (may be null)
+                    value_map_set(&mv, k, final_val);
+                    value_free(k);
+                    value_free(final_val);
+                    value_free(cur);
+                } else {
+                    Value v = eval_expr(interp, vexpr, env);
+                    if (interp->error) { value_free(k); value_free(mv); return value_null(); }
+                    value_map_set(&mv, k, v);
+                    value_free(k);
+                    value_free(v);
+                }
             }
             return mv;
         }

src/value.c

@@ -346,6 +346,26 @@ void value_map_delete(Value* mapval, Value key) {
     m->count--;
 }
 
+void value_map_set_self(Value* mapval, Value key) {
+    if (!mapval || mapval->type != VAL_MAP) return;
+    Map* m = mapval->as.map;
+    int idx = map_find_index(m, key);
+    if (idx >= 0) {
+        value_free(m->items[idx].value);
+        m->items[idx].value = value_alias(*mapval); // alias points to the same Map
+        return;
+    }
+    if (m->count + 1 > m->capacity) {
+        size_t newc = m->capacity == 0 ? 8 : m->capacity * 2;
+        m->items = realloc(m->items, sizeof(MapEntry) * newc);
+        if (!m->items) { fprintf(stderr, "Out of memory\n"); exit(1); }
+        m->capacity = newc;
+    }
+    m->items[m->count].key = value_copy(key);
+    m->items[m->count].value = value_alias(*mapval);
+    m->count++;
+}
+
 Value* value_map_get_ptr(Value* mapval, Value key, bool create_if_missing) {
     if (!mapval || mapval->type != VAL_MAP) return NULL;
     Map* m = mapval->as.map;

src/value.h

@@ -84,6 +84,9 @@ void value_map_set(Value* mapval, Value key, Value val);
 Value value_map_get(Value mapval, Value key, int* found);
 void value_map_delete(Value* mapval, Value key);
 
+// Set map entry value to an alias pointing to the map itself (SELF semantics)
+void value_map_set_self(Value* mapval, Value key);
+
 // Pointer helpers (for lvalue/indexed assignment)
 // Returns a pointer to the stored value for key, optionally creating a missing entry with NULL value.
 // Returned pointer is owned by the map; do NOT free it.

tests/test2.pre

@@ -159,6 +159,11 @@ MAP: m2 = <"a" = 101, "b" = 1010>
 ASSERT(EQ(KEYS(m2), ["a", "b"]))
 ASSERT(EQ(VALUES(m2), [101, 1010]))
 
+MAP: m3 = <"a" = 1, "b" = SELF<"a">, "c" = SELF>
+ASSERT(EQ(m3<"b">, 1))
+ASSERT(EQ(m3, m3<"c">))
+DEL(m3)
+
 ! Pointer tests
 PRINT("Testing pointers...")
 INT: x = 1