Commit: e0d54da70c476451ae1ca7a48ccbbe8c6b8e1139 - rpypkgs (git)

Nix flake for RPython interpreters

Commit MetaInfo

• Revision: e0d54da70c476451ae1ca7a48ccbbe8c6b8e1139 (tree)
• Time: 2024-06-06 13:57:37
• Author: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

regiux: Stub out binary ops.

The provided addition op works fine, first try. But I'm not going to be
worried about that. Why wouldn't it work? The curry is so very natural.
I was expecting an RPython error but the translator is generous today.

Change Summary

• modified: regiux/heap.py
• modified: regiux/parser.py

Incremental Difference

--- a/regiux/heap.py
+++ b/regiux/heap.py
@@ -25,6 +25,9 @@ class HeapObject(object):
     def unwrapBool(self):
         raise WrongType("Heap object type %s isn't a Boolean" %
                         self.__class__.__name__)
+    def unwrapInt(self):
+        raise WrongType("Heap object type %s isn't an integer" %
+                        self.__class__.__name__)
 
 class HeapTrue(HeapObject):
     _immutable_ = True
@@ -42,6 +45,7 @@ class HeapInt(HeapObject):
     _immutable_ = True
     def __init__(self, i): self.i = i
     def asStr(self): return str(self.i)
+    def unwrapInt(self): return self.i
 
 class HeapStr(HeapObject):
     _immutable_ = True
@@ -123,10 +127,23 @@ class HeapApp(MutableObject):
 
 class HeapAction(MutableObject):
     def __init__(self, action): self.action = action
-    def asStr(self): return "<internal lambda>"
+    def asStr(self): return "<internal lambda (unary)>"
     def apply(self, obj): return self.action(obj)
 
+class HeapBinary(MutableObject):
+    def __init__(self, action): self.action = action
+    def asStr(self): return "<internal lambda (binary)>"
+    def apply(self, obj): return HeapCurry(self.action, obj)
+
+class HeapCurry(MutableObject):
+    def __init__(self, action, x):
+        self.action = action
+        self.x = x
+    def asStr(self): return "<internal lambda (curried)>"
+    def apply(self, y): return self.action(self.x, y)
+
 builtins = HeapAttrSet({
+    "add": HeapBinary(lambda x, y: HeapInt(x.unwrapInt() + y.unwrapInt())),
     "length": HeapAction(lambda obj: HeapInt(obj.length())),
 })
 

--- a/regiux/parser.py
+++ b/regiux/parser.py
@@ -224,6 +224,10 @@ class ExprUnaryBox(BaseBox):
     def pretty(self):
         return "(%s%s)" % (self.op, self.expr.pretty())
 
+opDict = {
+    "+": "add",
+}
+
 class ExprBinaryBox(BaseBox):
     def __init__(self, left, right, op):
         self.left = left
@@ -231,6 +235,14 @@ class ExprBinaryBox(BaseBox):
         self.op = op.getstr()
     def pretty(self):
         return "(%s %s %s)" % (self.left.pretty(), self.op, self.right.pretty())
+    def compile(self, scope):
+        # XXX move to constructor or production?
+        assert self.op in opDict
+        verb = opDict[self.op]
+        return heap.HeapApp(
+                heap.HeapApp(heap.HeapSelect(scope["builtins"], [verb]),
+                             self.left.compile(scope)),
+                self.right.compile(scope))
 
 class HasBox(BaseBox):
     def __init__(self, value, path):