Add Atom HeapObject variant wrapping Arc<Mutex<SharedValue>>

Author: 0xhenrique

lisp/test_atoms.lisp

@@ -0,0 +1,91 @@
+(println "Testing atoms...")
+
+;; Test 1: Basic atom creation and deref
+(println "\n=== Test 1: Create and deref ===")
+(def counter (atom 0))
+(println "Initial value:" (deref counter))
+
+;; Test 2: reset! to change value
+(println "\n=== Test 2: reset! ===")
+(reset! counter 42)
+(println "After reset:" (deref counter))
+(reset! counter 100)
+(println "After second reset:" (deref counter))
+
+;; Test 3: swap! with increment
+(println "\n=== Test 3: swap! with increment ===")
+(def num (atom 10))
+(println "Initial:" (deref num))
+(swap! num + 5)
+(println "After (swap! num + 5):" (deref num))
+(swap! num + 10)
+(println "After (swap! num + 10):" (deref num))
+
+;; Test 4: swap! with multiply
+(println "\n=== Test 4: swap! with multiply ===")
+(def val (atom 3))
+(println "Initial:" (deref val))
+(swap! val * 2)
+(println "After (swap! val * 2):" (deref val))
+(swap! val * 5)
+(println "After (swap! val * 5):" (deref val))
+
+;; Test 5: Atoms with strings
+(println "\n=== Test 5: Atoms with strings ===")
+(def name (atom "Alice"))
+(println "Name:" (deref name))
+(reset! name "Bob")
+(println "After reset:" (deref name))
+
+;; Test 6: Atoms with lists
+(println "\n=== Test 6: Atoms with lists ===")
+(def items (atom (list 1 2 3)))
+(println "Items:" (deref items))
+(reset! items (list 4 5 6))
+(println "After reset:" (deref items))
+
+;; Test 7: Multiple atoms
+(println "\n=== Test 7: Multiple atoms ===")
+(def x (atom 1))
+(def y (atom 2))
+(def z (atom 3))
+(println "x:" (deref x) "y:" (deref y) "z:" (deref z))
+(swap! x + 10)
+(swap! y + 20)
+(swap! z + 30)
+(println "After swaps - x:" (deref x) "y:" (deref y) "z:" (deref z))
+(def sum (+ (deref x) (deref y) (deref z)))
+(println "Sum:" sum)
+
+;; Test 8: Atom shared between threads (each thread gets its own reference)
+(println "\n=== Test 8: Thread-local atom usage ===")
+(def worker (fn ()
+  (def local-atom (atom 0))
+  (swap! local-atom + 1)
+  (swap! local-atom + 2)
+  (swap! local-atom + 3)
+  (deref local-atom)))
+
+(def t1 (spawn worker))
+(def result (join t1))
+(println "Thread result:" result)
+
+;; Test 9: swap! with subtraction
+(println "\n=== Test 9: swap! with subtraction ===")
+(def balance (atom 100))
+(println "Balance:" (deref balance))
+(swap! balance - 30)
+(println "After withdrawal:" (deref balance))
+(swap! balance + 50)
+(println "After deposit:" (deref balance))
+
+;; Test 10: Displaying atoms
+(println "\n=== Test 10: Display atoms ===")
+(def a1 (atom 42))
+(def a2 (atom "hello"))
+(def a3 (atom (list 1 2 3)))
+(println "Atom with int:" a1)
+(println "Atom with string:" a2)
+(println "Atom with list:" a3)
+
+(println "\n=== All atom tests passed! ===")

src/value.rs

@@ -271,6 +271,9 @@ pub enum HeapObject {
     /// Channel receiver for inter-thread communication
     /// Wrapped in Arc<Mutex<>> to allow thread-safe access
     ChannelReceiver(Arc<Mutex<Receiver<SharedValue>>>),
+    /// Atomic reference for shared mutable state
+    /// Wrapped in Arc<Mutex<>> to allow thread-safe mutation
+    Atom(Arc<Mutex<SharedValue>>),
 }
 
 impl Clone for HeapObject {
@@ -286,6 +289,7 @@ impl Clone for HeapObject {
             HeapObject::ThreadHandle(h) => HeapObject::ThreadHandle(h.clone()),
             HeapObject::ChannelSender(s) => HeapObject::ChannelSender(s.clone()),
             HeapObject::ChannelReceiver(r) => HeapObject::ChannelReceiver(r.clone()),
+            HeapObject::Atom(a) => HeapObject::Atom(a.clone()),
         }
     }
 }
@@ -790,6 +794,7 @@ impl Value {
                 HeapObject::ThreadHandle(_) => "thread-handle",
                 HeapObject::ChannelSender(_) => "channel-sender",
                 HeapObject::ChannelReceiver(_) => "channel-receiver",
+                HeapObject::Atom(_) => "atom",
             }
         } else {
             "unknown"
@@ -988,6 +993,11 @@ impl Value {
                     let heap = Rc::new(HeapObject::ChannelReceiver(r.clone()));
                     Value::from_heap(heap)
                 }
+                Some(HeapObject::Atom(a)) => {
+                    // Atoms are already Arc-based, just clone the Value
+                    let heap = Rc::new(HeapObject::Atom(a.clone()));
+                    Value::from_heap(heap)
+                }
                 None => Value::nil(),
             }
         } else if self.is_ptr() {
@@ -1111,6 +1121,9 @@ impl Value {
             Some(HeapObject::ChannelReceiver(_)) => {
                 Err("Channel receivers cannot be converted to SharedValue (they are already thread-safe)".to_string())
             }
+            Some(HeapObject::Atom(_)) => {
+                Err("Atoms cannot be converted to SharedValue (they are already thread-safe)".to_string())
+            }
             None => Err("Cannot convert unknown value to SharedValue".to_string()),
         }
     }
@@ -1252,6 +1265,11 @@ impl fmt::Display for Value {
                 HeapObject::ThreadHandle(_) => write!(f, "<thread-handle>"),
                 HeapObject::ChannelSender(_) => write!(f, "<channel-sender>"),
                 HeapObject::ChannelReceiver(_) => write!(f, "<channel-receiver>"),
+                HeapObject::Atom(a) => {
+                    // Display the current value inside the atom
+                    let value = a.lock().unwrap();
+                    write!(f, "(atom {})", value)
+                }
             }
         } else {
             write!(f, "<unknown>")

src/vm.rs

@@ -2121,6 +2121,127 @@ pub fn standard_vm() -> VM {
         }
     }));
 
+    vm.define_global("atom", native("atom", |args| {
+        use std::sync::{Arc, Mutex};
+        use crate::value::HeapObject;
+
+        if args.len() != 1 {
+            return Err("atom expects 1 argument (initial value)".to_string());
+        }
+
+        // Convert initial value to SharedValue
+        let shared_value = args[0].make_shared()
+            .map_err(|e| format!("atom failed to convert initial value: {}", e))?;
+
+        // Create atom with Arc<Mutex<SharedValue>>
+        let atom_arc = Arc::new(Mutex::new(shared_value));
+        let atom_heap = Rc::new(HeapObject::Atom(atom_arc));
+
+        Ok(Value::from_heap(atom_heap))
+    }));
+
+    vm.define_global("deref", native("deref", |args| {
+        use crate::value::HeapObject;
+
+        if args.len() != 1 {
+            return Err("deref expects 1 argument (atom)".to_string());
+        }
+
+        // Get the atom
+        let atom_obj = args[0].as_heap()
+            .ok_or_else(|| "deref expects an atom".to_string())?;
+
+        if let HeapObject::Atom(atom_mutex) = atom_obj {
+            // Read the current value
+            let shared_value = atom_mutex.lock()
+                .map_err(|_| "Failed to lock atom".to_string())?;
+
+            // Convert back to Rc-based Value
+            Ok(Value::from_shared(&shared_value))
+        } else {
+            Err("deref expects an atom".to_string())
+        }
+    }));
+
+    vm.define_global("reset!", native("reset!", |args| {
+        use crate::value::HeapObject;
+
+        if args.len() != 2 {
+            return Err("reset! expects 2 arguments (atom new-value)".to_string());
+        }
+
+        // Get the atom
+        let atom_obj = args[0].as_heap()
+            .ok_or_else(|| "reset! expects an atom as first argument".to_string())?;
+
+        if let HeapObject::Atom(atom_mutex) = atom_obj {
+            // Convert new value to SharedValue
+            let new_shared = args[1].make_shared()
+                .map_err(|e| format!("reset! failed to convert new value: {}", e))?;
+
+            // Replace the value
+            let mut current = atom_mutex.lock()
+                .map_err(|_| "Failed to lock atom".to_string())?;
+            *current = new_shared.clone();
+
+            // Return the new value
+            Ok(Value::from_shared(&new_shared))
+        } else {
+            Err("reset! expects an atom as first argument".to_string())
+        }
+    }));
+
+    vm.define_global("swap!", native("swap!", |args| {
+        use crate::value::HeapObject;
+
+        if args.len() < 2 {
+            return Err("swap! expects at least 2 arguments (atom function [args...])".to_string());
+        }
+
+        // Get the atom
+        let atom_obj = args[0].as_heap()
+            .ok_or_else(|| "swap! expects an atom as first argument".to_string())?;
+
+        if let HeapObject::Atom(atom_mutex) = atom_obj {
+            // Get the function
+            let func = &args[1];
+
+            // Lock the atom
+            let mut current = atom_mutex.lock()
+                .map_err(|_| "Failed to lock atom".to_string())?;
+
+            // Convert current value back to Rc-based for function call
+            let current_value = Value::from_shared(&current);
+
+            // Build function call arguments: current value + any extra args
+            let mut func_args = vec![current_value];
+            if args.len() > 2 {
+                func_args.extend_from_slice(&args[2..]);
+            }
+
+            // Apply the function
+            let new_value = if let Some(nf) = func.as_native_function() {
+                (nf.func)(&func_args)?
+            } else if let Some(_chunk) = func.as_compiled_function() {
+                // For compiled functions, we need to create a VM and run the chunk
+                // For now, we'll only support native functions in swap!
+                return Err("swap! currently only supports native functions".to_string());
+            } else {
+                return Err("swap! expects a function as second argument".to_string());
+            };
+
+            // Convert result to SharedValue and update atom
+            let new_shared = new_value.make_shared()
+                .map_err(|e| format!("swap! failed to convert result: {}", e))?;
+            *current = new_shared.clone();
+
+            // Return the new value
+            Ok(Value::from_shared(&new_shared))
+        } else {
+            Err("swap! expects an atom as first argument".to_string())
+        }
+    }));
+
     vm
 }