initial commit

Author: Hong-Xiang

.gitignore

@@ -127,3 +127,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+.vscode/

README.md

@@ -1 +1,6 @@
-# purescript-arrays.py
+# A Python FFI provider for purescript-arrays.py
+Providing FFI files for https://github.com/purescript/purescript-arrays
+
+Available mirrors:
+
+https://github.com/purescript-python/purescript-python-ffi-index

python-ffi/Data/Array/NonEmpty/Internal.py

@@ -0,0 +1,62 @@
+import functools
+def fold1Impl(f): 
+    def result(xs):
+        acc = xs[0]
+        lxs = len(xs)
+        for i in range(1, lxs):
+            acc = f(acc)(xs[i])
+        return acc
+  return result
+
+class Cont:
+    def __init__(self, fn):
+        self.fn = fn
+
+class ConsCell:
+    def __init__(self, head, tail):
+        self.head = head
+        self.tail = tail
+
+def traverse1Impl(): 
+
+    emptyList = None
+
+    def finalCell(head):
+        return ConsCell(head, emptyList)
+    
+    def consList(x):
+        return lambda xs: ConsCell(x, xs)
+    
+    def listToArray(lst):
+        arr = []
+        xs = lst
+        while xs != emptyList:
+            arr.append(xs.head)
+            xs = xs.tail
+        return arr
+
+    
+
+    def _result(apply):
+        def l0(map_):
+            def l1(f):
+                def buildFrom(x, ys):
+                    return apply(map(consList)(f(x)))(ys)
+                def go(acc, currentLen, xs):
+                    if currentLen == 0:
+                        return acc
+                    else:
+                        last = xs[currentLen - 1]
+                        return Cont(lambda: go(buildFrom(last, acc), currentLen - 1, xs))
+                def _result2(array):
+                    acc = map_(finalCell)(f(array[array.length - 1]))
+                    result = go(acc, array.length - 1, array)
+                    while isinstance(result, Cont):
+                        result = result.fn()
+
+                    return map_(listToArray)(result)
+                return _result2
+            return l1
+        return l0     
+    return _result(None)
+

python-ffi/Data/Array/ST.py

@@ -0,0 +1,118 @@
+empty = lambda: []
+
+
+
+def peekImpl(just):
+    def _peekImpl(nothing, i, xs):
+        if i >= 0 and (i < len(xs)):
+            return just(xs[i])
+        else:
+            return nothing
+
+    return lambda nothing: lambda i: lambda xs: lambda: _peekImpl(nothing, i, xs)
+
+
+def _pokeImpl(i, a, xs, unit):
+    if i >= 0 and i < len(xs):
+        xs[i] = a
+
+
+poke = lambda i: lambda a: lambda xs: lambda: _pokeImpl(i, a, xs)
+
+
+popImpl = (
+    lambda just: lambda nothing: lambda xs: lambda: just(xs.pop())
+    if len(xs) > 0
+    else nothing
+)
+
+
+def _pushAllImpl(as_, xs):
+    xs.extends(as_)
+    return len(xs)
+
+
+pushAll = lambda as_: lambda xs: lambda: _pushAllImpl(as_, xs)
+
+
+# exports.pushAll = function (as) {
+#   return function (xs) {
+#     return function () {
+#       return xs.push.apply(xs, as);
+#     };
+#   };
+# };
+
+
+def _shiftImpl(just, nothing, xs):
+    if len(xs) > 0:
+        return just(xs[1:])
+    else:
+        return nothing
+
+
+shiftImpl = (
+    lambda just: lambda nothing: lambda xs: lambda: just(xs.pop(0))
+    if len(xs) > 0
+    else nothing
+)
+
+
+def _unshiftAllImpl(as_, xs):
+    xs[len(as_) :] = xs[:]
+    xs[: len(as_)] = as_
+    return len(xs)
+
+
+unshiftAll = lambda as_: lambda xs: lambda: _unshiftAllImpl(as_, xs)
+
+
+# exports.unshiftAll = function (as) {
+#   return function (xs) {
+#     return function () {
+#       return xs.unshift.apply(xs, as);
+#     };
+#   };
+# };
+
+
+def _spliceImpl(i, howMany, bs, xs):
+    s = i if i >= 0 else len(xs) + i
+    removed = xs[s : s + howMany]
+    xs[s + len(bs) :] = xs[s + len(removed) :]
+    xs[s : s + len(bs)] = bs[:]
+    return removed
+
+
+splice = lambda i: lambda howMany: lambda bs: lambda xs: lambda: _spliceImpl(
+    i, howMany, bs, xs
+)
+
+# exports.splice = function (i) {
+#   return function (howMany) {
+#     return function (bs) {
+#       return function (xs) {
+#         return function () {
+#           return xs.splice.apply(xs, [i, howMany].concat(bs));
+#         };
+#       };
+#     };
+#   };
+# };
+
+
+unsafeFreeze = lambda xs: lambda: xs
+
+unsafeThaw = lambda xs: lambda: xs
+
+copyImpl = lambda xs: lambda: xs[:]
+
+freeze = copyImpl
+thaw = copyImpl
+
+
+sortByImpl = lambda comp: lambda xs: lambda: sorted(xs, cmp=comp)
+
+
+def toAssocArray(xs):
+    return [{"value": x, "index": i} for i, x in enumerate(xs)]

python-ffi/Data/Array/ST/Partial.py

@@ -0,0 +1,10 @@
+def peekImpl(i):
+    return lambda xs: lambda: xs[i]
+
+
+def _pokeImpl(xs, i, a):
+    xs[i] = a
+
+
+def pokeImpl(i):
+    return lambda a: lambda xs: lambda: _pokeImpl(xs, i, a)