Promises (#440)

* Promises

* Force too I guess

* Use the correct slots

Author: chrisrink10

src/basilisp/core.lpy

@@ -821,6 +821,29 @@
   [x]
   (instance? basilisp.lang.delay/Delay x))
 
+(defn force
+  "If x is a Delay, returned the possibly cached value of x. Otherwise, return
+  x."
+  [x]
+  (if (delay? x)
+    @x
+    x))
+
+(defn promise
+  "Return a promise object which can be set exactly once using `deliver`.
+  Readers may block waiting for the value of the promise using `@` or `deref`.
+  If the value has already been realized, then reading the value of the
+  promise will not block. Readers may check if the promise has been delivered
+  using `realized?`."
+  []
+  (basilisp.lang.promise/Promise))
+
+(defn deliver
+  "Deliver the value v to the promise p. If p already has a value, then a
+  subsequent call to `deliver` for p will have no effect."
+  [p v]
+  (.deliver p v))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Arithmetic Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;

src/basilisp/lang/compiler/generator.py

@@ -434,6 +434,7 @@ def _is_redefable(v: Var) -> bool:
 _LIST_ALIAS = genname("llist")
 _MAP_ALIAS = genname("lmap")
 _MULTIFN_ALIAS = genname("multifn")
+_PROMISE_ALIAS = genname("promise")
 _READER_ALIAS = genname("reader")
 _RUNTIME_ALIAS = genname("runtime")
 _SEQ_ALIAS = genname("seq")
@@ -454,6 +455,7 @@ def _is_redefable(v: Var) -> bool:
     "basilisp.lang.list": _LIST_ALIAS,
     "basilisp.lang.map": _MAP_ALIAS,
     "basilisp.lang.multifn": _MULTIFN_ALIAS,
+    "basilisp.lang.promise": _PROMISE_ALIAS,
     "basilisp.lang.reader": _READER_ALIAS,
     "basilisp.lang.runtime": _RUNTIME_ALIAS,
     "basilisp.lang.seq": _SEQ_ALIAS,

src/basilisp/lang/delay.py

@@ -37,7 +37,7 @@ def __deref(state: _DelayState) -> _DelayState:
             return _DelayState(f=state.f, value=state.f(), computed=True)
 
     def deref(self) -> Optional[T]:
-        return self._state.swap(Delay.__deref).value
+        return self._state.swap(self.__deref).value
 
     @property
     def is_realized(self) -> bool:

src/basilisp/lang/promise.py

@@ -0,0 +1,36 @@
+import threading
+from typing import Optional, TypeVar
+
+from basilisp.lang.interfaces import IBlockingDeref
+
+T = TypeVar("T")
+
+
+# pylint: disable=assigning-non-slot
+class Promise(IBlockingDeref[T]):
+    __slots__ = ("_condition", "_is_delivered", "_value")
+
+    def __init__(self) -> None:
+        self._condition = threading.Condition()
+        self._is_delivered = False
+        self._value: Optional[T] = None
+
+    def deliver(self, value: T):
+        with self._condition:
+            if not self._is_delivered:
+                self._is_delivered = True
+                self._value = value
+
+    def deref(
+        self, timeout: Optional[float] = None, timeout_val: Optional[T] = None
+    ) -> Optional[T]:
+        with self._condition:
+            if self._condition.wait_for(lambda: self._is_delivered, timeout=timeout):
+                return self._value
+            else:
+                return timeout_val
+
+    @property
+    def is_realized(self) -> bool:
+        with self._condition:
+            return self._is_delivered

src/basilisp/lang/runtime.py

@@ -390,6 +390,7 @@ class Namespace:
                     "basilisp.lang.list",
                     "basilisp.lang.map",
                     "basilisp.lang.multifn",
+                    "basilisp.lang.promise",
                     "basilisp.lang.reader",
                     "basilisp.lang.runtime",
                     "basilisp.lang.seq",

tests/basilisp/promise_test.py

@@ -0,0 +1,29 @@
+import threading
+
+import basilisp.lang.vector as vec
+from basilisp.lang.promise import Promise
+
+
+def test_promise():
+    v = vec.v(1, 2, 3)
+
+    p = Promise()
+    assert False is p.is_realized
+
+    def set_promise():
+        p.deliver(v)
+
+    assert "not set yet" == p.deref(timeout=0.2, timeout_val="not set yet")
+    assert False is p.is_realized
+
+    t = threading.Thread(target=set_promise)
+    t.start()
+    t.join()
+
+    assert v == p.deref()
+    assert True is p.is_realized
+
+    p.deliver("another value")
+
+    assert v == p.deref()
+    assert True is p.is_realized