gh-46: Make MAP and TNS atomic.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -211,9 +211,11 @@
 
 Additionally, the symbol `*` MAY be used in an index position to denote a full-dimension slice selecting every element along that axis (for example, `tensor[*,1]` selects all elements of the first dimension at index `1` of the second dimension).
 
-All other tensor operations are non-mutating: tensor literals and tensor-valued built-ins produce new tensor values rather than mutating existing ones. Because indexed assignment mutates a tensor object, if the same tensor value is aliased (bound to multiple identifiers, passed as an argument, or stored inside another tensor), all aliases observe the mutation.
+All other tensor operations are non-mutating: tensor literals and tensor-valued built-ins produce new tensor values rather than mutating existing ones. Because indexed assignment mutates a tensor object, if the same tensor value is explicitly aliased, all aliases observe the mutation.
 
-MAP and `TNS` values are reference (aliasing) types: assigning a `MAP` or `TNS` to another identifier copies a reference to the same underlying container rather than performing an implicit deep copy. Mutating a map (via `map<...> = ...`, `DEL`, or other mutating operators) or mutating a tensor element through indexed assignment will be observed through any other identifier that references the same container. Use the built-in `COPY` (shallow copy) or `DEEPCOPY` (recursive deep copy) operators when a non-aliased duplicate is REQUIRED.
+MAP and `TNS` values are atomic (de-referenced) types: assigning a `MAP` or `TNS` to another identifier copies (duplicates) the container object so that subsequent mutations to one binding do not affect the other by default. The runtime provides explicit copy semantics to control sharing:
+
+When shared, aliased containers are required, developers should use pointer references (with `@`).
 
 Every runtime value has a static type: `INT`, `FLT`, `STR`, `TNS`, `MAP`, `THR`, or `FUNC`. Integers are conceptually unbounded mathematical integers. Floats are IEEE754 binary floating-point numbers. Strings are sequences of characters (source text is ASCII, but escape codes MAY denote non-ASCII code points). Tensors are non-scalar aggregates whose elements MAY be `INT`, `FLT`, `STR`, `MAP`, `THR`, `FUNC`, or `TNS`. Maps are associative containers mapping scalar keys (`INT`, `FLT`, or `STR`) to values of a single static type. Threads are handles to parallel code blocks. Functions are user-defined code blocks with lexical closures.
 

src/builtins.c

@@ -5771,7 +5771,8 @@ static Value builtin_match(Interpreter* interp, Value* args, int argc, Expr** ar
 // COPY (shallow copy for scalars)
 static Value builtin_copy(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
     (void)arg_nodes; (void)env; (void)interp; (void)line; (void)col;
-    return value_copy(args[0]);
+    /* Preserve existing COPY operator behavior (shallow/aliasing). */
+    return value_alias(args[0]);
 }
 
 // DEEPCOPY: return a recursive deep copy of the argument

src/interpreter.c

@@ -1959,6 +1959,13 @@ ExecResult assign_index_chain(Interpreter* interp, Env* env, Expr* idx_expr, Val
 
 cleanup:
     free(nodes);
+    // If assignment succeeded, write back the possibly-modified base value
+    // into the environment so that atomic container semantics persist.
+    if (out.status == EXEC_OK) {
+        if (!env_assign(env, base_name, base_val, TYPE_UNKNOWN, false)) {
+            out = make_error("Cannot write back to identifier (frozen?)", stmt_line, stmt_col);
+        }
+    }
     value_free(base_val);
     return out;
 }

src/value.c

@@ -382,9 +382,66 @@ Value* value_tns_get_ptr(Value v, const size_t* idxs, size_t nidxs) {
 
 // Shallow copy semantics: increment refcount for MAP/TNS and return aliasing Value.
 Value value_copy(Value v) {
+    // New semantics: value_copy produces an atomic (de-referenced) copy for
+    // container types (TNS and MAP): the container object is duplicated so
+    // mutations to the returned value won't affect the original. Element
+    // values inside the container remain as aliases (not deep-copied).
+    Value out = v;
+    if (v.type == VAL_STR && v.as.s) {
+        out.as.s = strdup(v.as.s);
+    } else if (v.type == VAL_TNS && v.as.tns) {
+        Tensor* t = v.as.tns;
+        // allocate new tensor structure and copy shape/strides
+        Tensor* t2 = malloc(sizeof(Tensor));
+        if (!t2) { fprintf(stderr, "Out of memory\n"); exit(1); }
+        t2->elem_type = t->elem_type;
+        t2->ndim = t->ndim;
+        t2->shape = malloc(sizeof(size_t) * t2->ndim);
+        t2->strides = malloc(sizeof(size_t) * t2->ndim);
+        for (size_t i = 0; i < t2->ndim; i++) { t2->shape[i] = t->shape[i]; t2->strides[i] = t->strides[i]; }
+        t2->length = t->length;
+        t2->data = malloc(sizeof(Value) * t2->length);
+        for (size_t i = 0; i < t2->length; i++) {
+            // keep element references (shallow): use value_alias to preserve
+            // previous element-sharing semantics for nested containers
+            extern Value value_alias(Value v);
+            t2->data[i] = value_alias(t->data[i]);
+        }
+        t2->refcount = 1;
+        mtx_init(&t2->lock, 0);
+        out.as.tns = t2;
+    } else if (v.type == VAL_MAP && v.as.map) {
+        Map* m = v.as.map;
+        Map* m2 = malloc(sizeof(Map));
+        if (!m2) { fprintf(stderr, "Out of memory\n"); exit(1); }
+        m2->count = m->count;
+        m2->capacity = m->count;
+        m2->items = malloc(sizeof(MapEntry) * (m2->capacity ? m2->capacity : 1));
+        for (size_t i = 0; i < m->count; i++) {
+            extern Value value_alias(Value v);
+            m2->items[i].key = value_alias(m->items[i].key);
+            m2->items[i].value = value_alias(m->items[i].value);
+        }
+        m2->refcount = 1;
+        mtx_init(&m2->lock, 0);
+        out.as.map = m2;
+    } else if (v.type == VAL_THR && v.as.thr) {
+        // threads remain shared handles
+        Thr* th = v.as.thr;
+        mtx_lock(&th->state_lock);
+        th->refcount++;
+        mtx_unlock(&th->state_lock);
+        out.as.thr = th;
+    }
+    return out;
+}
+
+// Alias/shallow-copy helper: preserve previous semantics where MAP/TNS
+// were reference types. This function performs the former behavior of
+// `value_copy` (increment refcounts and return aliasing container).
+Value value_alias(Value v) {
     Value out = v;
     if (v.type == VAL_STR && v.as.s) {
-        // Duplicate strings to preserve independent ownership semantics for STR
         out.as.s = strdup(v.as.s);
     } else if (v.type == VAL_TNS && v.as.tns) {
         Tensor* t = v.as.tns;
@@ -406,6 +463,7 @@ Value value_copy(Value v) {
         out.as.thr = th;
     }
     return out;
+
 }
 
 // Deep-copy helper: recursively duplicate container contents.

src/value.h

@@ -110,6 +110,7 @@ int value_thr_get_started(Value v);
 // Note: pointer semantics are implemented at the EnvEntry (alias) level; no PTR Value type.
 
 Value value_copy(Value v);
+Value value_alias(Value v);
 Value value_deep_copy(Value v);
 void value_free(Value v);