Initial commit

Author: Mike Solomon

.gitignore

@@ -0,0 +1,23 @@
+/bower_components/
+/node_modules/
+/.pulp-cache/
+/output/
+/generated-docs/
+/.psc-package/
+/.psc*
+/.purs*
+/.psa*
+/.spago
+/.venv
+/.vscode
+
+purescript_aff
+
+# purescript-python
+.pure-py/
+
+# purescript-python
+.pure-py/
+
+# purescript-python
+.pure-py/

README.md

@@ -0,0 +1,3 @@
+# purescript-avar.py
+
+A port of avar to purescript-python

python-ffi/Effect/AVar.py

@@ -0,0 +1,301 @@
+import threading
+
+
+class EMPTY:
+    pass
+
+
+class MutableQueue:
+    def __init__(self):
+        self.head = None
+        self.last = None
+        self.size = 0
+
+
+class MutableCell:
+    def __init__(self, queue, value):
+        self.queue = queue
+        self.value = value
+        self.next = None
+        self.prev = None
+
+
+class AVar:
+    def __init__(self, value):
+        self.draining = False
+        self.error = None
+        self.value = value
+        self.takes = MutableQueue()
+        self.reads = MutableQueue()
+        self.puts = MutableQueue()
+
+
+class ____:
+    @staticmethod
+    def runEff(eff):
+        try:
+            eff()
+        except Exception as e:
+
+            def _throw():
+                raise e
+
+            t = threading.Thread(target=_throw)
+            t.start()
+
+    @staticmethod
+    def putLast(queue, value):
+        cell = MutableCell(queue, value)
+        if queue.size == 0:
+            queue.head = cell
+        elif queue.size == 1:
+            cell.prev = queue.head
+            queue.head.next = cell
+            queue.last = cell
+
+        else:
+            cell.prev = queue.last
+            queue.last.next = cell
+            queue.last = cell
+
+        queue.size += 1
+        return cell
+
+    @staticmethod
+    def takeLast(queue):
+        cell = None
+        if queue.size == 0:
+            return None
+        if queue.size == 1:
+            cell = queue.head
+            queue.head = None
+        elif queue.size == 2:
+            cell = queue.last
+            queue.head.next = None
+            queue.last = None
+        else:
+            cell = queue.last
+            queue.last = cell.prev
+            queue.last.next = None
+        cell.prev = None
+        cell.queue = None
+        queue.size -= 1
+        return cell.value
+
+    @staticmethod
+    def takeHead(queue):
+        cell = None
+        if queue.size == 0:
+            return None
+        if queue.size == 1:
+            cell = queue.head
+            queue.head = None
+        elif queue.size == 2:
+            cell = queue.head
+            queue.last.prev = None
+            queue.head = queue.last
+            queue.last = None
+        else:
+            cell = queue.head
+            queue.head = cell.next
+            queue.head.prev = None
+        cell.next = None
+        cell.queue = None
+        queue.size -= 1
+        return cell.value
+
+    @staticmethod
+    def deleteCell(cell):
+        if cell.queue == None:
+            return None
+        if cell.queue.last == cell:
+            ____.takeLast(cell.queue)
+            return None
+        if cell.queue.head == cell:
+            ____.takeHead(cell.queue)
+            return None
+        if cell.prev:
+            cell.prev.next = cell.next
+        if cell.next:
+            cell.next.prev = cell.prev
+        cell.queue.size -= 1
+        cell.queue = None
+        cell.value = None
+        cell.next = None
+        cell.prev = None
+
+    @staticmethod
+    def drainVar(util, avar):
+        if avar.draining:
+            return None
+        ps = avar.puts
+        ts = avar.takes
+        rs = avar.reads
+        p = None
+        r = None
+        t = None
+        value = None
+        rsize = None
+        avar.draining = True
+        while True:
+            p = None
+            r = None
+            t = None
+            value = avar.value
+            rsize = rs.size
+            if avar.error is not None:
+                value = util["left"](avar.error)
+                while True:
+                    p = ____.takeHead(ps)
+                    if p is None:
+                        break
+                    ____.runEff(p.cb(value))
+                while True:
+                    r = ____.takeHead(rs)
+                    if r is None:
+                        break
+                    ____.runEff(r(value))
+                while True:
+                    t = ____.takeHead(ts)
+                    if t is None:
+                        break
+                    ____.runEff(t(value))
+                break
+            if value == EMPTY:
+                p = ____.takeHead(ps)
+                if p:
+                    avar.value = p.value
+                    value = p.value
+            if value != EMPTY:
+                t = ____.takeHead(ts)
+                while rsize > 0:
+                    rsize -= 1
+                    r = ____.takeHead(rs)
+                    if not r:
+                        break
+                    ____.runEff(r(util["right"](value)))
+                if t is not None:
+                    avar.value = EMPTY
+                    ____.runEff(t(util["right"](value)))
+            if p is not None:
+                ____.runEff(p.cb(util["right"](None)))
+            if ((avar.value == EMPTY) and (ps.size == 0)) or (
+                (avar.value != EMPTY) and (ts.size == 0)
+            ):
+                break
+        avar.draining = False
+
+
+def empty():
+    return AVar(EMPTY)
+
+
+def _newVar(value):
+    def _newVar1():
+        return AVar(value)
+
+    return _newVar1
+
+
+def _killVar(util, error, avar):
+    def _killVar1():
+        if avar.error == None:
+            avar.error = error
+            avar.value = EMPTY
+            ____.drainVar(util, avar)
+
+    return _killVar1
+
+
+class Puttable:
+    def __init__(self, cb, value):
+        self.cb = cb
+        self.value = value
+
+
+def _putVar(util, value, avar, cb):
+    def _putVar1():
+        cell = ____.putLast(avar.puts, Puttable(cb, value))
+        ____.drainVar(util, avar)
+
+        def _putVar2():
+            ____.deleteCell(cell)
+
+        return _putVar2
+
+    return _putVar1
+
+
+def _takeVar(util, avar, cb):
+    def _takeVar1():
+        cell = ____.putLast(avar.takes, cb)
+        ____.drainVar(util, avar)
+
+        def _takeVar2():
+            ____.deleteCell(cell)
+
+        return _takeVar2
+
+    return _takeVar1
+
+
+def _readVar(util, avar, cb):
+    def _readVar1():
+        cell = ____.putLast(avar.reads, cb)
+        ____.drainVar(util, avar)
+
+        def _readVar2():
+            ____.deleteCell(cell)
+
+        return _readVar2
+
+    return _readVar1
+
+
+def _tryPutVar(util, value, avar):
+    def _tryPutVar1():
+        if (avar.value == EMPTY) and (avar.error == None):
+            avar.value = value
+            ____.drainVar(util, avar)
+            return True
+        else:
+            return False
+
+    return _tryPutVar1
+
+
+def _tryTakeVar(util, avar):
+    def _tryTakeVar1():
+        value = avar.value
+        if value == EMPTY:
+            return util["nothing"]
+        else:
+            avar.value = EMPTY
+            ____.drainVar(util, avar)
+            return util["just"](value)
+
+    return _tryTakeVar1
+
+
+def _tryReadVar(util, avar):
+    def _tryReadVar1():
+        if avar.value == EMPTY:
+            return util["nothing"]
+        else:
+            return util["just"](avar.value)
+
+    return _tryReadVar1
+
+
+def _status(util, avar):
+    def _status1():
+        if avar.error:
+            return util["killed"](avar.error)
+
+        if avar.value == EMPTY:
+            return util["empty"]
+
+        return util["filled"](avar.value)
+
+    return _status1
+