提交: 90d9bc9042fe04d7cc376d16dfb049446b5031d9 - cammy (git)

A categorical programming language

Commit MetaInfo

• 修订版: 90d9bc9042fe04d7cc376d16dfb049446b5031d9 (tree)
• 时间: 2022-03-12 23:26:47
• 作者: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Build a DAG while loading expressions into a hive.

更改概述

• modified: cammy-rpy/cammylib/hive.py
• modified: cammy-rpy/cammylib/sexp.py
• modified: default.nix
• add: hive/bool/if.cammy
• modified: hive/fun/iter.cammy
• add: hive/fun/observe.cammy
• add: hive/list/append.cammy
• add: hive/list/double.cammy
• add: hive/nat/double-alt.cammy
• modified: hive/nat/double.cammy
• add: hive/nat/rshift.cammy
• add: hive/pair/mapfst.cammy
• add: hive/pair/mapsnd.cammy
• modified: shell.nix
• modified: todo.txt

差异

--- a/cammy-rpy/cammylib/hive.py
+++ b/cammy-rpy/cammylib/hive.py
@@ -16,6 +16,7 @@ class Hive(object):
     def __init__(self, hivepath):
         self.hivepath = hivepath
         self.exprs = {}
+        self.dag = {}
 
     def load(self, atom):
         if atom in self.exprs:
@@ -27,6 +28,9 @@ class Hive(object):
         try:
             with open(fullpath, "r") as handle:
                 sexp, trail = parse(handle.read())
+                symbols = {}
+                sexp.symbols(symbols)
+                self.dag[atom] = symbols
                 sexp = sexp.canonicalize(self)
                 self.exprs[atom] = sexp
                 # print("Loaded", atom, sexp)

--- a/cammy-rpy/cammylib/sexp.py
+++ b/cammy-rpy/cammylib/sexp.py
@@ -27,6 +27,9 @@ class Atom(SExp):
     def asStr(self):
         return self.symbol
 
+    def symbols(self, s):
+        s[self.symbol] = None
+
     def substitute(self, args):
         return self
 
@@ -65,6 +68,11 @@ class Functor(SExp):
         args = " ".join([arg.asStr() for arg in self.arguments])
         return "(%s %s)" % (self.constructor, args)
 
+    def symbols(self, s):
+        s[self.constructor] = None
+        for arg in self.arguments:
+            arg.symbols(s)
+
     def substitute(self, args):
         return Functor(self.constructor,
                 [arg.substitute(args) for arg in self.arguments])
@@ -120,6 +128,9 @@ class Hole(SExp):
     def asStr(self):
         return "@%d" % self.index
 
+    def symbols(self, s):
+        pass
+
     def substitute(self, args):
         return args[self.index]
 

--- a/default.nix
+++ b/default.nix
@@ -3,6 +3,7 @@ let
   inherit (nixpkgs) pkgs;
   jelly = (import jelly/Cargo.nix { pkgs = nixpkgs; }).rootCrate.build;
   movelist = import ./movelist { inherit nixpkgs; };
+  cammy-comb = import ./cammy-rpy/comb.nix { inherit nixpkgs jelly; };
   cammy-draw = import ./cammy-rpy/draw.nix { inherit nixpkgs jelly; };
   cammy-frame = import ./cammy-rpy/frame.nix { inherit nixpkgs jelly; };
   cammy-repl = import ./cammy-rpy/repl.nix { inherit nixpkgs jelly; };
@@ -25,6 +26,7 @@ in pkgs.stdenv.mkDerivation {
     makeWrapper ${jelly}/bin/jelly $out/bin/cammy-jelly
 
     # RPython tools
+    makeWrapper ${cammy-comb}/bin/cammy-comb $out/bin/cammy-comb
     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

--- /dev/null
+++ b/hive/bool/if.cammy
@@ -0,0 +1,3 @@
+(comp either (case (fun/name @0) (fun/name @1)))
+
+As close as we can get to an if-expression.

--- a/hive/fun/iter.cammy
+++ b/hive/fun/iter.cammy
@@ -1 +1,3 @@
 (pr (fun/name id) (comp (pair id (fun/const (fun/name @0))) fun/int-comp))
+
+Iterate a given arrow zero or more times.

--- /dev/null
+++ b/hive/fun/observe.cammy
@@ -0,0 +1,3 @@
+(fun/flip (comp (pair (fun/const (fun/name @0)) (fun/iter @1)) fun/int-comp))
+
+Observe the value of an endomorphism after a specified number of iterations.

--- /dev/null
+++ b/hive/list/append.cammy
@@ -0,0 +1,3 @@
+(comp (pair/mapfst list/reverse) list/reverse-onto) 
+
+Concatenate two lists into a single list.

--- /dev/null
+++ b/hive/list/double.cammy
@@ -0,0 +1,3 @@
+(fold nil (comp (pair fst cons) cons))
+
+Repeat each value in a list twice.

--- /dev/null
+++ b/hive/nat/double-alt.cammy
@@ -0,0 +1,3 @@
+(pr zero (comp succ succ))
+
+Double a natural number by counting every successor operation twice.

--- a/hive/nat/double.cammy
+++ b/hive/nat/double.cammy
@@ -1 +1,3 @@
 (comp fun/dup nat/add)
+
+Double a natural number by adding it to itself.

--- /dev/null
+++ b/hive/nat/rshift.cammy
@@ -0,0 +1,8 @@
+(pr
+  (pair zero f)
+  (fun/apppair
+    (comp snd (bool/if (pair succ (fun/const f)) (pair id (fun/const t))))
+    fst))
+
+Shift all of the bits in a natural number towards the least-significant bit.
+The least-significant bit itself is also returned.

--- /dev/null
+++ b/hive/pair/mapfst.cammy
@@ -0,0 +1,3 @@
+(pair (comp fst @0) snd)
+
+Map over the first component of a pair.

--- /dev/null
+++ b/hive/pair/mapsnd.cammy
@@ -0,0 +1,3 @@
+(pair fst (comp snd @0))
+
+Map over the second component of a pair.

--- a/shell.nix
+++ b/shell.nix
@@ -14,7 +14,9 @@ in pkgs.stdenv.mkDerivation {
     egg2nix
     # maintaining cammy-rpy/
     pythonPackages.pyflakes
-    # developing cammy-weave
+    # using cammy-comb
+    graphviz
+    # using cammy-weave
     pandoc texlive.combined.scheme-small
     # using cammy-repl
     rlwrap

--- a/todo.txt
+++ b/todo.txt
@@ -6,7 +6,6 @@
 * list/eq : [X × X, 2] → [[X] × [X], 2]
 * list/zip : [X] × [Y] → [X × Y]
 * list/tail : [X] → [X]
-* list/append : [X] × [X] → [X]
 * rat
 * refactoring from the bikeshed: ignore -> !
   * Might not be important since fun/const is the only user!
@@ -43,11 +42,9 @@
     * X -> X: should be id?
     * X -> 1: should be ignore
     * 1 -> 2: should be t or f
-* New int type
-  * Current type: quotient of N × N under subtraction
-    * big, tricky case analysis, big quotient overlap
-  * Proposed type: quotient of N + N gluing zero
-    * almost minimal, sign bit, quotient glues exactly two elements into one
 * Refactoring tools
   * Find all leaves in a hive
   * Rename an expression and change all callers
+* Maybe allow inductive datatype definitions during toolchain build time
+  * Start by factoring out N and lists into inductive datatype modules somehow
+  * Then add trees, etc.