提交: 0bc7131ef99cb227b2b358ba4379526e8d2fa711 - cammy (git)

A categorical programming language

Commit MetaInfo

• 修订版: 0bc7131ef99cb227b2b358ba4379526e8d2fa711 (tree)
• 时间: 2022-03-02 11:00:55
• 作者: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Add :! command to REPL for evaluating elements.

I should probably add typechecking, because it also will try to evaluate
non-elements.

更改概述

• modified: README.txt
• modified: cammy-rpy/cammylib/arrows.py
• modified: cammy-rpy/repl.py
• delete: cammy-simplify.sh
• delete: cammy-weave.py
• modified: default.nix
• modified: hive/f/dot2.cammy
• add: hive/f/dot2pair.cammy
• add: hive/fun/tensor.cammy
• add: hive/mat2/id.cammy
• add: hive/mat2/mul.cammy
• add: hive/mat2/trans.cammy
• add: hive/mat2/vec.cammy
• add: hive/mat2/vecpair.cammy
• modified: hive/nat/is_even.cammy
• add: hive/nat/is_odd.cammy
• modified: todo.txt

差异

--- a/README.txt
+++ b/README.txt
@@ -36,3 +36,14 @@ The environment for developing the Cammy toolchain is contained within
 To update eggs for the shell environment:
 
     $ egg2nix eggs.scm > eggs.nix
+
+# Hive Documentation
+
+The toolchain can generate documentation for hives. To generate PDF
+documentation:
+
+    $ cammy-weave hive/ | pandoc -o doc.pdf
+
+And to generate HTML documentation:
+
+    $ cammy-weave hive/ | pandoc --mathml -o doc.html

--- a/cammy-rpy/cammylib/arrows.py
+++ b/cammy-rpy/cammylib/arrows.py
@@ -34,22 +34,19 @@ class Element(object):
 
 class T(Element):
     _immutable_ = True
+    def asStr(self): return "*"
 
 class B(Element):
     _immutable_ = True
-    def __init__(self, b):
-        self._b = b
-
-    def b(self):
-        return self._b
+    def __init__(self, b): self._b = b
+    def b(self): return self._b
+    def asStr(self): return "true" if self._b else "false"
 
 class N(Element):
     _immutable_ = True
-    def __init__(self, bi):
-        self._bi = bi
-
-    def n(self):
-        return self._bi
+    def __init__(self, bi): self._bi = bi
+    def n(self): return self._bi
+    def asStr(self): return self._bi.str()
 
 class F(Element):
     _immutable_ = True
@@ -62,6 +59,8 @@ class F(Element):
     def f(self):
         return self._f
 
+    def asStr(self): return str(self._f)
+
 class P(Element):
     _immutable_ = True
 
@@ -75,6 +74,8 @@ class P(Element):
     def second(self):
         return self._y
 
+    def asStr(self): return "(%s, %s)" % (self._x.asStr(), self._y.asStr())
+
 class L(Element):
     _immutable_ = True
 
@@ -84,6 +85,9 @@ class L(Element):
     def tagged(self, f, g):
         return f.run(self._x)
 
+    def asStr(self):
+        return "L(%s)" % self._x.asStr()
+
 class R(Element):
     _immutable_ = True
 
@@ -93,6 +97,9 @@ class R(Element):
     def tagged(self, f, g):
         return g.run(self._x)
 
+    def asStr(self):
+        return "R(%s)" % self._x.asStr()
+
 class H(Element):
     _immutable_ = True
     def __init__(self, f, x):
@@ -100,6 +107,8 @@ class H(Element):
         self._x = x
     def apply(self, y):
         return self._f.run(P(self._x, y))
+    def asStr(self):
+        return "%s @ %s" % (self._f, self._x.asStr())
 
 class Xs(Element):
     _immutable_ = True
@@ -107,6 +116,8 @@ class Xs(Element):
     def __init__(self, xs):
         self.xs = xs
     def l(self): return self.xs
+    def asStr(self):
+        return "[%s]" % ", ".join([x.asStr() for x in self.xs])
 
 class Arrow(object):
     _immutable_ = True

--- a/cammy-rpy/repl.py
+++ b/cammy-rpy/repl.py
@@ -1,11 +1,10 @@
 # Inspired by https://www.pypy.org/posts/2018/11/guest-post-implementing-calculator-repl-6271483514675006846.html
 
-import os
 import sys
 
 from rpython.rlib.rfile import create_stdio
 
-from cammylib.arrows import BuildProblem
+from cammylib.arrows import BuildProblem, T
 from cammylib.hive import Hive, MissingAtom
 from cammylib.jelly import jellify
 from cammylib.parser import parse
@@ -13,10 +12,15 @@ from cammylib.types import ConstraintStore, TypeExtractor, UnificationFailed
 
 LINE_BUFFER_LENGTH = 1024
 
-def command(code, line):
-    if code == "e":
-        # Edit a file
-        os.system("$EDITOR")
+def command(hive, code, line):
+    # XXX code e: Edit a file
+    # os.system("$EDITOR")
+    if code == "!":
+        sexp, trail = parse(line)
+        sexp = sexp.canonicalize(hive)
+        sexp = jellify(sexp)
+        arrow = sexp.buildArrow()
+        print arrow.run(T()).asStr()
 
 def repl(hive, stdin, stdout):
     while True:
@@ -28,7 +32,8 @@ def repl(hive, stdin, stdout):
         if line.startswith(":"):
             if len(line) < 2:
                 print "Not a full command"
-            command(line[1], line[3:])
+            command(hive, line[1], line[3:])
+            continue
         sexp, trail = parse(line)
         print "Got:", line
         print "S-expression:", sexp.asStr()

--- a/cammy-simplify.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!@bash@/bin/bash
-
-# set -x
-set -eu -o pipefail
-
-frame="@frame@/bin/frame"
-jelly="@jelly@/bin/jelly"
-
-hive="$1"
-
-# Do it all.
-exec $frame $hive | $jelly

--- a/cammy-weave.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!@python3@/bin/python3
-
-import sys
-
-def offset_list(s):
-    count = 0
-    for i, c in enumerate(s):
-        if c == '(':
-            count += 1
-        elif c == ')':
-            count -= 1
-        if not count:
-            return i + 1
-    raise Exception("Runaway Cammy expression has %d unclosed parentheses" % count)
-
-def offset_atom(s):
-    for i, c in enumerate(s):
-        if c == ' ' or c == '\n':
-            return i
-    return len(s)
-
-def untangle(s):
-    offset = offset_list(s) if s.startswith('(') else offset_atom(s)
-    return s[:offset], s[offset:].strip()
-
-if __name__ == "__main__":
-    expr, doc = untangle(sys.stdin.read())
-    command = sys.argv[1]
-    if command == "strip":
-        print(expr)
-    else:
-        raise Exception("Unknown command %s" % command)

--- a/default.nix
+++ b/default.nix
@@ -37,17 +37,13 @@ in pkgs.stdenv.mkDerivation {
       --subst-var frame --subst-var jelly --subst-var movelist
     chmod +x $out/bin/cammy-build
 
-    substitute $src/cammy-simplify.sh $out/bin/cammy-simplify \
-      --subst-var bash \
-      --subst-var frame --subst-var jelly --subst-var movelist
-    chmod +x $out/bin/cammy-simplify
-
-    substitute $src/cammy-weave.py $out/bin/cammy-weave \
-      --subst-var python3
-    chmod +x $out/bin/cammy-weave
-
+    # To be removed
     makeWrapper ${movelist}/bin/movelist $out/bin/cammy-movelist
 
+    # jelly
+    makeWrapper ${jelly}/bin/jelly $out/bin/cammy-jelly
+
+    # RPython tools
     makeWrapper ${cammy-draw}/bin/cammy-draw $out/bin/cammy-draw
     makeWrapper ${cammy-frame}/bin/cammy-frame $out/bin/cammy-frame
     makeWrapper ${cammy-repl}/bin/cammy-repl $out/bin/cammy-repl

--- a/hive/f/dot2.cammy
+++ b/hive/f/dot2.cammy
@@ -1,3 +1,5 @@
 (f/addpair
   (f/mulpair (comp fst fst) (comp snd fst))
   (f/mulpair (comp fst snd) (comp snd snd)))
+
+The dot product of two two-dimensional vectors.

--- /dev/null
+++ b/hive/f/dot2pair.cammy
@@ -0,0 +1 @@
+(comp (pair @0 @1) f/dot2)

--- /dev/null
+++ b/hive/fun/tensor.cammy
@@ -0,0 +1,11 @@
+(pair (comp fst @0) (comp snd @1))
+
+Compose two arrows in parallel, acting on pairs of values.
+
+In categorical jargon, the [tensor
+product](https://ncatlab.org/nlab/show/tensor+product) is a functor from pairs
+of arrows to arrows:
+
+$$
+\bigotimes : C \times C \to C
+$$

--- /dev/null
+++ b/hive/mat2/id.cammy
@@ -0,0 +1,5 @@
+(pair
+    (pair f-one f-zero)
+    (pair f-zero f-one))
+
+An identity matrix.

--- /dev/null
+++ b/hive/mat2/mul.cammy
@@ -0,0 +1,7 @@
+(comp
+    (fun/tensor id mat2/trans)
+    (pair
+        (mat2/vecpair fst (comp snd fst))
+        (mat2/vecpair fst (comp snd snd))))
+
+Multiply two matrices.

--- /dev/null
+++ b/hive/mat2/trans.cammy
@@ -0,0 +1,5 @@
+(pair
+    (pair (comp fst fst) (comp snd fst))
+    (pair (comp fst snd) (comp snd snd)))
+
+Transpose a matrix.

--- /dev/null
+++ b/hive/mat2/vec.cammy
@@ -0,0 +1,5 @@
+(pair
+    (f/dot2pair (comp fst fst) snd)
+    (f/dot2pair (comp fst snd) snd))
+
+Apply a matrix to a column vector.

--- /dev/null
+++ b/hive/mat2/vecpair.cammy
@@ -0,0 +1 @@
+(comp (pair @0 @1) mat2/vec)

--- a/hive/nat/is_even.cammy
+++ b/hive/nat/is_even.cammy
@@ -1 +1,3 @@
 (pr t not)
+
+Whether a natural number is even. Zero is even.

--- /dev/null
+++ b/hive/nat/is_odd.cammy
@@ -0,0 +1,3 @@
+(comp nat/is_even not)
+
+Whether a natural number is odd.

--- a/todo.txt
+++ b/todo.txt
@@ -4,14 +4,13 @@
     - cammy-weave $HIVE: document a hive
     * cammy-tangle $HIVE: take an expression on stdin, return framed optimized
       expression on stdout
-      * cammy-frame $HIVE | jelly
+      - cammy-frame $HIVE | cammy-jelly
     - cammy-draw ...: take an expression and canvas params, make a PNG
     - cammy-frame $HIVE: take an expression on stdin, return framed expression
       on stdout
-    * cammy-jelly $EXPR: print an optimized expression on stdout
-      * $EXPR is a path!
-        * This is wholly due to RPython issues
-      * When $EXPR is "-", read from stdin
+    - cammy-jelly: print an optimized expression on stdout
+    - cammy-djinn $TY $TY: synthesize a function with the given signature
+      - uses last bit of movelist code
 * REPL improvements
   * allow mid-functor newlines
   * jellification
@@ -30,18 +29,16 @@
 * list/append : [X] × [X] → [X]
 * rat
 * refactoring from the bikeshed: ignore -> !
-* Typechecker needs to handle holes
-* Typechecker should handle polymorphism better
-* Typechecker errors are inscrutable
-* Trigonometric functions
-  * f-atan2 added, need f-sin and f-cos?
-  * Optimizations for odd/even functions?
+  * Might not be important since fun/const is the only user!
 * Transcendental and other constants
   * Euler's constant e
   * Euler's constant gamma
 * Remove movelist djinn, maybe?
 * Double-negation monad for CPS?
+  * Cont is available but not fully developed
+    * monads/cont/join, monads/cont/bind, etc.
 * fun/name should always start from 1
+  * Requires changing some callers
 * Prove that nat/add is smallest with its behavior
 * Streams
   * Monad: X → [N, X]
@@ -58,3 +55,4 @@
   * Moore transducers: [Q × S, Q] -> [Q × S, Q]
 * Mealy machines: For state type Q, input type S, and output type L, Q × S -> Q × L
 * Jets
+* f/dot2pair