Commit: 8fa9e079783349f7a06efab4512c30b44b05f46a - cammy (git)

A categorical programming language

Commit MetaInfo

• Revision: 8fa9e079783349f7a06efab4512c30b44b05f46a (tree)
• Time: 2024-10-25 15:03:35
• Author: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Use regexes to parse inject/project/nats/ords.

Change Summary

• modified: cammy/cammylib/arrows.py
• modified: cammy/cammylib/cam.py
• modified: todo.txt

Incremental Difference

--- a/cammy/cammylib/arrows.py
+++ b/cammy/cammylib/arrows.py
@@ -2,6 +2,7 @@ import math
 
 from rpython.rlib.objectmodel import specialize
 # from rpython.rlib.rbigint import rbigint
+from rpython.rlib.rsre import rsre_re as re
 
 from cammylib.elements import F, N, thePoint, theTrue, theFalse
 
@@ -479,53 +480,54 @@ class Nat(Arrow):
     def compileCAM(self, compiler): compiler.quote(N(self.n))
     def types(self, cs): return cs.concrete("1"), cs.concrete("N")
 
+RE_INJECT = re.compile("^i(\d+)o(\d+)$")
+RE_PROJECT = re.compile("^p(\d+)o(\d+)$")
+RE_NAT = re.compile("^n(\d+)(o(\d+))?$")
+
 def buildUnary(name):
     if name in unaryFunctors: return unaryFunctors[name]
-    elif name.startswith("i"):
-        o = name[1:]
-        # XXX regex instead?
+    elif RE_INJECT.match(name):
+        m = RE_INJECT.match(name)
         try:
-            ok, on = o.split("o", 1)
-            k = int(ok)
-            n = int(on)
+            k = int(m.group(1))
+            n = int(m.group(2))
             if n < 2:
                 raise BuildProblem("The smallest ordinal is 2, not %d" % n)
             if not (0 <= k < n):
                 raise BuildProblem("Invalid ordinal index: %d of %d" % (k, n))
             return Inject(k, n)
-        except ValueError: raise BuildProblem("Invalid ordinal pair: " + o)
-    elif name.startswith("p"):
-        o = name[1:]
-        # XXX regex instead?
+        except ValueError: raise BuildProblem("Invalid ordinal pair: " + name)
+    elif RE_PROJECT.match(name):
+        m = RE_PROJECT.match(name)
         try:
-            ok, on = o.split("o", 1)
-            k = int(ok)
-            n = int(on)
+            k = int(m.group(1))
+            n = int(m.group(2))
             if n < 2:
                 raise BuildProblem("The smallest ordinal is 2, not %d" % n)
             if not (0 <= k < n):
                 raise BuildProblem("Invalid ordinal index: %d of %d" % (k, n))
             return Project(k, n)
-        except ValueError: raise BuildProblem("Invalid ordinal pair: " + o)
-    elif name.startswith("n"):
-        if "o" in name:
-            ok, on = name[1:].split("o", 1)
-            k = int(ok)
-            n = int(on)
+        except ValueError: raise BuildProblem("Invalid ordinal pair: " + name)
+    elif RE_NAT.match(name):
+        m = RE_NAT.match(name)
+        if m.group(2) is None:
+            try: return Nat(int(m.group(1)))
+            except ValueError:
+                raise BuildProblem("Invalid natural number: " + name)
+        else:
+            k = int(m.group(1))
+            n = int(m.group(3))
             if n < 2:
                 raise BuildProblem("The smallest ordinal is 2, not %d" % n)
             if not (0 <= k < n):
                 raise BuildProblem("Invalid ordinal index: %d of %d" % (k, n))
             return Ord(k, n)
-        k = name[1:]
-        try: return Nat(int(k))
-        except ValueError: raise BuildProblem("Invalid natural number: " + k)
     else:
         raise BuildProblem("Invalid unary functor: " + name)
 
 def buildCompound(name, args):
     if name == "comp" and len(args) >= 2: return Comp(args)
-    elif name == "tuple" and len(args) >= 2: return Tuple(args)
+    elif name in ("pair", "tuple") and len(args) >= 2: return Tuple(args)
     elif name == "case" and len(args) >= 2: return Case(args)
     elif name == "curry" and len(args) == 1:
         return Curry(args[0])

--- a/cammy/cammylib/cam.py
+++ b/cammy/cammylib/cam.py
@@ -141,7 +141,7 @@ termOps = [
 ]
 print "CAM: Created %d term ops" % len(termOps)
 
-HAVE_PARAMS = QUOTE, CUR, GOTO, CALL, GOTORIGHT, GOTOTAG, PROJECT, SLICETUPLE
+HAVE_PARAMS = QUOTE, CUR, GOTO, CALL, GOTORIGHT, GOTOTAG, INJECT, PROJECT, SLICETUPLE
 LABEL_PARAM = CUR, GOTO, CALL, GOTORIGHT, GOTOTAG
 assert set(LABEL_PARAM) < set(HAVE_PARAMS), "implementation error"
 def hasParam(op): return op in HAVE_PARAMS

--- a/todo.txt
+++ b/todo.txt
@@ -153,6 +153,9 @@
         * Need promotion Ord(X) -> N
           * prom = (opr zero succ) : Ord(X) -> N
             * Jet it!
+        * Need conversion to sums Ord(X) -> 1 + 1 + ...
+          * Mostly need a good name
+          * Internal bytecode is makeTag, yields a term op
         * Need fractions Ord(X) -> F
           * Could do it if given compile-time cardinality Ord(X) -> N
             * card : Ord(X) -> N
@@ -537,5 +540,5 @@
   * Current big refactor
     * Inject and project
       * Bytecodes could be term ops, but term ops can't take params!
-      * Regexes might give us a simpler and more portable specification of
-        acceptable syntax
+        * This actually needs to get fixed so that we can use inject/project
+          to replace fst/snd/left/right