提交: fa785ac4caa51c1cba07ad64cd38331ede22201a - cammy (git)

A categorical programming language

Commit MetaInfo

• 修订版: fa785ac4caa51c1cba07ad64cd38331ede22201a (tree)
• 时间: 2022-07-13 00:40:27
• 作者: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Display trails in the REPL when available.

更改概述

• modified: cammy-rpy/repl.py
• add: hive/3b1b-horner.cammy
• add: hive/3b1b-newton-poly.cammy
• add: hive/f/-1.cammy
• add: hive/l.cammy
• add: hive/nat/horner.cammy
• modified: hive/poly/horner.cammy
• add: hive/v2/complex/conjugate.cammy
• add: hive/v2/complex/horner.cammy
• modified: todo.txt

差异

--- a/cammy-rpy/repl.py
+++ b/cammy-rpy/repl.py
@@ -139,6 +139,7 @@ def repl(hive, stdin, stdout):
                 print "Not a full command"
             command(hive, line[1], line[3:], context)
             continue
+        lineIsAtom = not line.startswith("(")
         sexp, trail = parse(line)
         # Save the original expr for next time.
         mostRecentExpr = sexp
@@ -163,6 +164,14 @@ def repl(hive, stdin, stdout):
             print "Couldn't build arrow:", bp.message
         except UnificationFailed as uf:
             print "Couldn't check type:", uf.message
+        # Try to print trails for atoms in the hive.
+        if lineIsAtom:
+            # Clean the line to improve the odds of success.
+            line = line.split(" ", 1)[0].strip()
+            try:
+                print "Trail:", hive.exprs[line][2].strip()
+            except KeyError:
+                pass
     return 0
 
 def doREPL(hivepath):

--- /dev/null
+++ b/hive/3b1b-horner.cammy
@@ -0,0 +1 @@
+(comp (pair (fun/const 3b1b-newton-poly) id) v2/complex/horner)
\ No newline at end of file

--- /dev/null
+++ b/hive/3b1b-newton-poly.cammy
@@ -0,0 +1 @@
+(l v2/complex/one (l v2/complex/zero (l v2/complex/zero (l v2/complex/one (l (pair f/-1 f-zero) (l v2/complex/one nil))))))
\ No newline at end of file

--- /dev/null
+++ b/hive/f/-1.cammy
@@ -0,0 +1 @@
+(comp f-one f-negate)
\ No newline at end of file

--- /dev/null
+++ b/hive/l.cammy
@@ -0,0 +1 @@
+(pair/of cons @0 @1)
\ No newline at end of file

--- /dev/null
+++ b/hive/nat/horner.cammy
@@ -0,0 +1,3 @@
+(poly/horner zero nat/add nat/mul)
+
+Evaluate a polynomial in the natural numbers with Horner's rule.

--- a/hive/poly/horner.cammy
+++ b/hive/poly/horner.cammy
@@ -1,11 +1,15 @@
 (comp
   (pair/mapfst list/reverse)
   (uncurry (fold
-    (fun/name (fun/const zero))
+    (fun/name (fun/const @0))
     (curry (comp
       (pair (pair fstfst (fun/apppair fstsnd snd)) snd)
-      (pair/of nat/add
-        (pair/of nat/mul fstsnd snd)
+      (pair/of @1
+        (pair/of @2 fstsnd snd)
         fstfst))))))
 
-Evaluate a polynomial at an input coordinate using Horner's rule.
+Evaluate a polynomial at an input coordinate using Horner's rule, given:
+
+* A target coordinate for the zero polynomial
+* An addition for coefficients
+* A multiplication for coordinates

--- /dev/null
+++ b/hive/v2/complex/conjugate.cammy
@@ -0,0 +1 @@
+(pair/mapsnd f-negate)
\ No newline at end of file

--- /dev/null
+++ b/hive/v2/complex/horner.cammy
@@ -0,0 +1 @@
+(poly/horner v2/complex/zero v2/complex/add v2/complex/mul)
\ No newline at end of file

--- a/todo.txt
+++ b/todo.txt
@@ -91,8 +91,7 @@
   * Would be nice to know how long it takes, too
   * Parameterize by number of iterations?
 * Native code generation with QBE
-  * Strategy: Emit one procedure for each expression under a (curry) or
-    (uncurry), defunctionalizing
+  * Strategy: Defunctionalize each (curry) and emit a native procedure
     * Should arity be implied, so that these procedures can take their pairs
       as two arguments?
   * Execution proceeds by compiling our CAM code into QBE templates
@@ -169,7 +168,6 @@
     * while-loops and mutable variables
 * More jets from natural bytecodes
   * snoc = (comp swap cons)
-  * dup
   * foldr = (comp list/reverse list/foldl)
     * but also, foldl = (comp list/reverse list/foldr)
       * so we effectively have fast foldl and fast reverse?
@@ -177,12 +175,11 @@
         * reverse is implemented as a tight loop in linear time, but it still
           does a linear number of heap allocations
   * fun/app = (uncurry id)
+    * done
     * uncurry distills down to fun/app, as in the literature
       * (uncurry @0) could be defined as (comp (pair/mapfst @0) fun/app)
-  * Done for nat/add and nat/pred-maybe
-    * Makes Project Euler (6) possible, accelerates demos
-  * pair/swap = (pair snd fst)
-    * this might be fundamental to symmetric monoidal categories or CCCs
+  * list/uncons
+    * has particularly simple bytecode, becoming a term op
 * Peephole optimization misses opportunities
   * Assume two rules
     * QUOTE; DUP -> QUOTE (term op)
@@ -201,3 +198,9 @@
   * (comp f-log1p f-exp) => (comp (pair (fun/const f-one) id) f/add)
 * Lentz's algorithm
   * https://en.wikipedia.org/wiki/Lentz's_algorithm
+* What's a parser again?
+  * A parser from strings of X to Y: [X] -> Y × [X]
+    * An instance of state monad
+  * Multiple results: [X] -> [Y × [X]]
+    * blends non-determinism and state
+* Render 3b1b's simple iterated Newton fractal