Commit: master - cammy (git)

A categorical programming language

Commit MetaInfo

• Révision: 06d54b6826960957451cbd73a9f8ab2602805f66 (tree)
• l'heure: 2024-11-25 06:23:56
• Auteur: Corbin <cds@corb...>
• Commiter: Corbin

Message de Log

Allow pairing of domains.

I'm so pissed that I couldn't do this in a nice generic fashion. This
works, but it's ugly and verbose.

Change Summary

• modified: cammy/cammylib/mixins.py
• modified: cammy/repl.py

Modification

--- a/cammy/cammylib/mixins.py
+++ b/cammy/cammylib/mixins.py
@@ -1,3 +1,7 @@
+import inspect
+
+from rpython.rlib.objectmodel import import_from_mixin
+
 class InvalidCammy(Exception):
     def __init__(self, message): self.message = message
 
@@ -23,7 +27,7 @@ class Cammy(object):
     def uncurry(self, arr): pass
     # natural numbers object
     def nat(self, k): pass
-    def succ(self, arr): pass
+    def succ(self): pass
     def pr(self, f, g): pass
     # ordinal objects
     def ord(self, k, n): pass
@@ -85,3 +89,48 @@ class Cammy(object):
                                     self.curry(self.comp([self.tuple([self.app(),
                                                                       self.snd()]),
                                                           self.n_add()]))))
+
+
+def PairOf(d1, d2):
+    class PairDomain(object):
+        import_from_mixin(Cammy)
+        def __init__(self, d1, d2):
+            self.d1 = d1
+            self.d2 = d2
+
+        def hole(self, i): return self.d1.hole(i), self.d2.hole(i)
+        def substitute(self, args):
+            return (self.d1.substitute([arg[0] for arg in args]),
+                    self.d2.substitute([arg[1] for arg in args]))
+        def comp(self, arrs):
+            return (self.d1.comp([arr[0] for arr in arrs]),
+                    self.d2.comp([arr[1] for arr in arrs]))
+        def project(self, k, n):
+            return self.d1.project(k, n), self.d2.project(k, n)
+        def tuple(self, arrs):
+            return (self.d1.tuple([arr[0] for arr in arrs]),
+                    self.d2.tuple([arr[1] for arr in arrs]))
+        def inject(self, k, n):
+            return self.d1.inject(k, n), self.d2.inject(k, n)
+        def case(self, arrs):
+            return (self.d1.case([arr[0] for arr in arrs]),
+                    self.d2.case([arr[1] for arr in arrs]))
+        def curry(self, arr):
+            return self.d1.curry(arr[0]), self.d2.curry(arr[1])
+        def uncurry(self, arr):
+            return self.d1.uncurry(arr[0]), self.d2.uncurry(arr[1])
+        def nat(self, k): return self.d1.nat(k), self.d2.nat(k)
+        def pr(self, f, g):
+            return self.d1.pr(f[0], g[0]), self.d2.pr(f[1], g[1])
+        def ord(self, k, n): return self.d1.ord(k, n), self.d2.ord(k, n)
+        def fold(self, f, g):
+            return self.d1.fold(f[0], g[0]), self.d2.fold(f[1], g[1])
+        def tfold(self, f, g):
+            return self.d1.tfold(f[0], g[0]), self.d2.tfold(f[1], g[1])
+
+        for verb, meth in inspect.getmembers(Cammy, inspect.ismethod):
+            if verb.startswith("__"): continue
+            argspec = inspect.getargspec(meth)
+            if len(argspec[0]) != 1: continue
+            exec """def {verb}(self): return self.d1.{verb}(), self.d2.{verb}()""".format(verb=verb)
+    return PairDomain(d1, d2)

--- a/cammy/repl.py
+++ b/cammy/repl.py
@@ -6,6 +6,7 @@ from rpython.rlib.rfile import create_stdio
 
 from cammylib.cam import CompileToCAM
 from cammylib.elements import T, N
+from cammylib.mixins import PairOf
 from cammylib.parser import makeParser, ParseError
 from cammylib.sexp import Atom, Functor
 from cammylib.types import TypeCheck, ConstraintStore, TypeExtractor, TypeFormatter, UnificationFailed, fixDomain
@@ -68,12 +69,13 @@ class PrintHelp(Command):
 
 parseAndTypeCheck = makeParser("TypeChecker", TypeCheck())
 parseToCAM = makeParser("Compiler", CompileToCAM())
+parseToBoth = makeParser("TypeCheckAndCompile",
+                         PairOf(TypeCheck(), CompileToCAM()))
 
 class EvaluateElement(Command):
     doc = "Evaluate an element or sequence. Elements are arrows from 1; sequences are elements from N."
     def run(self, line):
-        subst, trail = parseAndTypeCheck(line)
-        ca, trail = parseToCAM(line)
+        (subst, ca), trail = parseToBoth(line)
         # If the arrow is polymorphic, monomorphize it.
         if fixDomain(subst, Atom("1")): printElement(ca.finish())
         # Maybe it's a sequence?