Add atoms to core lib, supplement delay (#133)

* Add atoms to core lib, supplement delay

* Add runtime tests

* Fix linter errors

Author: chrisrink10

basilisp/core/__init__.lpy

@@ -216,3 +216,33 @@
    (if (seq (rest args))
      (recur (operator/add x (first args)) (rest args))
      (operator/add x (first args)))))
+
+(defn deref
+  "Dereference an atom and returns its contents."
+  [o]
+  (basilisp.lang.runtime/deref o))
+
+(defn reset!
+  "Reset the value of an atom to v without regard to the previous value.
+  Return the new value."
+  [atom v]
+  (let [current (deref atom)]
+    (if (.compare-and-set atom current v)
+      v
+      (recur atom v))))
+
+(defn swap!
+  "Atomically swap the value of an atom to the return value of (apply f
+  current-value args). The function f may be called multiple times while
+  swapping, so should be free of side effects. Return the new value."
+  [atom f & args]
+  (apply basilisp.lang.runtime/swap atom f args))
+
+(defn atom
+  "Return an Atom containing v. The value of an Atom at any point in time
+  may be returned by deref'ing it. The value of an atom may be reset using
+  reset! and may be swapped using swap!. All operations on an atom occur
+  atomically."
+  [v]
+  (basilisp.lang.atom/Atom v))
+

basilisp/lang/atom.py

@@ -1,3 +1,26 @@
-import atomos.atom as atom
+from typing import Generic, TypeVar, Callable
 
-Atom = atom.Atom
+import atomos.atom
+
+from basilisp.lang.deref import Deref
+
+T = TypeVar('T')
+
+
+class Atom(Deref, Generic[T]):
+    __slots__ = ('_atom',)
+
+    def __init__(self, state: T) -> None:
+        self._atom = atomos.atom.Atom(state)
+
+    def compare_and_set(self, old, new):
+        return self._atom.compare_and_set(old, new)
+
+    def deref(self) -> T:
+        return self._atom.deref()
+
+    def reset(self, v: T) -> T:
+        return self._atom.reset(v)
+
+    def swap(self, f: Callable[..., T], *args, **kwargs) -> T:
+        return self._atom.swap(f, *args, **kwargs)

basilisp/lang/delay.py

@@ -1,20 +1,28 @@
-from typing import Callable, Any
+from typing import Callable, TypeVar
 
 import basilisp.lang.atom as atom
 import basilisp.lang.map as lmap
+from basilisp.lang.deref import Deref
 
+T = TypeVar('T')
 
-class Delay:
+
+class Delay(Deref[T]):
     __slots__ = ('_state',)
 
-    def __init__(self, f: Callable[[], Any]) -> None:
-        self._state = atom.Atom(lmap.m(f=f, value=None, computed=False))
+    def __init__(self, f: Callable[[], T]) -> None:
+        self._state = atom.Atom(lmap.m(f=f, value=None, computed=False))  # pylint:disable=assigning-non-slot
+
+    @staticmethod
+    def __deref(m: lmap.Map):
+        if m["computed"]:
+            return m
+        else:
+            return m.assoc("value", m["f"](), "computed", True)
 
-    def deref(self) -> Any:
-        def __deref(m: lmap.Map):
-            if m["computed"]:
-                return m
-            else:
-                return m.assoc("value", m["f"](), "computed", True)
+    def deref(self) -> T:
+        return self._state.swap(Delay.__deref).value
 
-        return self._state.swap(__deref).value
+    @property
+    def is_realized(self) -> bool:
+        return self._state.deref()["computed"]

basilisp/lang/deref.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Generic
+
+T = TypeVar('T')
+
+
+class Deref(ABC, Generic[T]):
+    __slots__ = ()
+
+    @abstractmethod
+    def deref(self) -> T:
+        raise NotImplementedError()

basilisp/lang/runtime.py

@@ -9,6 +9,7 @@
 
 import basilisp.lang.associative as lassoc
 import basilisp.lang.collection as lcoll
+import basilisp.lang.deref as lderef
 import basilisp.lang.list as llist
 import basilisp.lang.map as lmap
 import basilisp.lang.seq as lseq
@@ -176,6 +177,8 @@ class Namespace:
       namespace"""
     DEFAULT_IMPORTS = atom.Atom(pset(seq(['builtins',
                                           'operator',
+                                          'basilisp.lang.atom',
+                                          'basilisp.lang.delay',
                                           'basilisp.lang.exception',
                                           'basilisp.lang.keyword',
                                           'basilisp.lang.list',
@@ -498,6 +501,20 @@ def conj(coll, *xs):
     raise TypeError(f"Object of type {type(coll)} does not implement Collection interface")
 
 
+def deref(o):
+    """Dereference a Deref object and return its contents."""
+    if isinstance(o, lderef.Deref):
+        return o.deref()
+    raise TypeError(f"Object of type {type(o)} cannot be dereferenced")
+
+
+def swap(a: atom.Atom, f, *args):
+    """Atomically swap the value of an atom to the return value of (apply f
+    current-value args). The function f may be called multiple times while
+    swapping, so should be free of side effects. Return the new value."""
+    return a.swap(f, *args)
+
+
 def _collect_args(args) -> lseq.Seq:
     """Collect Python starred arguments into a Basilisp list."""
     if isinstance(args, tuple):

basilisp/lang/seq.py

@@ -162,7 +162,7 @@ def cons(self, elem):
         return Cons(elem, self)
 
     @property
-    def realized(self):
+    def is_realized(self):
         return self._realized
 
     def __iter__(self):

tests/atom_test.py

@@ -0,0 +1,23 @@
+import basilisp.lang.atom as atom
+import basilisp.lang.deref as lderef
+import basilisp.lang.map as lmap
+import basilisp.lang.vector as vec
+
+
+def test_atom_deref_interface():
+    assert isinstance(atom.Atom(1), lderef.Deref)
+    assert issubclass(atom.Atom, lderef.Deref)
+
+
+def test_atom():
+    a = atom.Atom(vec.Vector.empty())
+    assert vec.Vector.empty() == a.deref()
+
+    assert vec.v(1) == a.swap(lambda v, e: v.cons(e), 1)
+    assert vec.v(1) == a.deref()
+
+    assert vec.v(1, 2) == a.swap(lambda v, e: v.cons(e), 2)
+    assert vec.v(1, 2) == a.deref()
+
+    assert vec.v(1, 2) == a.reset(lmap.Map.empty())
+    assert lmap.Map.empty() == a.deref()

tests/delay_test.py

@@ -5,10 +5,16 @@
 def test_delay(capsys):
     d = delay.Delay(lambda: vec.v(print("In Delay Now"), 1, 2, 3))
 
+    assert False is d.is_realized
+
     assert vec.v(None, 1, 2, 3) == d.deref()
     captured = capsys.readouterr()
     assert "In Delay Now\n" == captured.out
 
+    assert True is d.is_realized
+
     assert vec.v(None, 1, 2, 3) == d.deref()
     captured = capsys.readouterr()
     assert "" == captured.out
+
+    assert True is d.is_realized

tests/runtime_test.py

@@ -1,5 +1,6 @@
 import pytest
 
+import basilisp.lang.atom as atom
 import basilisp.lang.keyword as keyword
 import basilisp.lang.list as llist
 import basilisp.lang.map as lmap
@@ -203,6 +204,25 @@ def test_conj():
         runtime.conj("b", 1, "a")
 
 
+def test_deref():
+    assert 1 == runtime.deref(atom.Atom(1))
+    assert vec.Vector.empty() == runtime.deref(atom.Atom(vec.Vector.empty()))
+
+    with pytest.raises(TypeError):
+        runtime.deref(1)
+
+    with pytest.raises(TypeError):
+        runtime.deref(vec.Vector.empty())
+
+
+def test_swap():
+    assert 3 == runtime.swap(atom.Atom(1), lambda x, y: x + y, 2)
+    assert vec.v(1) == runtime.swap(atom.Atom(vec.Vector.empty()), lambda v, e: v.cons(e), 1)
+
+    with pytest.raises(AttributeError):
+        runtime.swap(1, lambda x, y: x + y, 2)
+
+
 def test_trampoline_args():
     args = runtime._TrampolineArgs(True)
     assert () == args.args

tests/seq_test.py

@@ -13,21 +13,21 @@ def test_lazy_sequence():
     assert not s.is_empty, "LazySeq has not been realized yet"
     assert None is s.first
     assert lseq.empty() == s.rest
-    assert s.realized
+    assert s.is_realized
     assert s.is_empty, "LazySeq has been realized and is empty"
 
     s = lseq.LazySeq(lambda: lseq.empty())
     assert not s.is_empty, "LazySeq has not been realized yet"
     assert None is s.first
     assert lseq.empty() == s.rest
-    assert s.realized
+    assert s.is_realized
     assert s.is_empty, "LazySeq has been realized and is empty"
 
     s = lseq.LazySeq(lambda: lseq.sequence([1]))
     assert not s.is_empty, "LazySeq has not been realized yet"
     assert 1 == s.first
     assert lseq.empty() == s.rest
-    assert s.realized
+    assert s.is_realized
     assert not s.is_empty, "LazySeq has been realized and is not empty"
 
     def lazy_seq():
@@ -43,21 +43,21 @@ def inner_inner_seq():
     assert not s.is_empty, "LazySeq has not been realized yet"
     assert 1 == s.first
     assert isinstance(s.rest, lseq.LazySeq)
-    assert s.realized
+    assert s.is_realized
     assert not s.is_empty, "LazySeq has been realized and is not empty"
 
     r = s.rest
     assert not r.is_empty, "LazySeq has not been realized yet"
     assert 2 == r.first
     assert isinstance(r.rest, lseq.LazySeq)
-    assert r.realized
+    assert r.is_realized
     assert not r.is_empty, "LazySeq has been realized and is not empty"
 
     t = r.rest
     assert not t.is_empty, "LazySeq has not been realized yet"
     assert 3 == t.first
     assert lseq.empty() == t.rest
-    assert t.realized
+    assert t.is_realized
     assert not t.is_empty, "LazySeq has been realized and is not empty"
 
     assert [1, 2, 3] == [e for e in s]