提交: 545291094d5b7db322b545c1557fd4c788745f6b - cammy (git)

A categorical programming language

Commit MetaInfo

• 修訂: 545291094d5b7db322b545c1557fd4c788745f6b (tree)
• 時間: 2022-07-25 06:28:24
• 作者: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Damn you're fast.

Change Summary

• modified: cammy-rpy/cammylib/parser.py
• modified: cammy-rpy/cammylib/types.py
• modified: cammy-rpy/repl.py
• add: hive/bool-sum.cammy
• add: hive/bool/ternary.cammy
• add: hive/combinators/k.cammy
• add: hive/combinators/s.cammy
• add: hive/combinators/w.cammy
• add: hive/comonads/product/bind.cammy
• add: hive/comonads/reader/counit.cammy
• add: hive/comonads/reader/duplicate.cammy
• add: hive/comonads/store/duplicate.cammy
• add: hive/hailstone.cammy
• add: hive/list-choose.cammy
• add: hive/list/flatmap.cammy
• add: hive/list/kata.cammy
• add: hive/list/para.cammy
• add: hive/list/tails.cammy
• add: hive/monad-choose.cammy
• add: hive/monads/state/join.cammy
• add: hive/monads/subset/add.cammy
• add: hive/monads/subset/guard.cammy
• add: hive/monads/subset/join.cammy
• add: hive/monads/subset/unit.cammy
• add: hive/monads/subset/zero.cammy
• add: hive/monads/writer/join.cammy
• add: hive/monads/writer/map.cammy
• add: hive/monads/writer/unit.cammy
• add: hive/monads/writer/write.cammy
• add: hive/monoids/add/add.cammy
• add: hive/monoids/add/zero.cammy
• add: hive/monoids/mul/add.cammy
• add: hive/monoids/mul/zero.cammy
• add: hive/nat-div2.cammy
• add: hive/nat-mul3.cammy
• add: hive/nat/kata.cammy
• modified: hive/nat/para.cammy
• add: hive/poly/deriv.cammy
• add: hive/poly/nice-deriv.cammy
• add: hive/subset-choose.cammy
• add: hive/subset-range.cammy
• add: hive/swap-curry.cammy
• add: hive/triang.cammy
• modified: jelly/src/main.rs
• modified: movelist/test.json
• modified: todo.txt

差異

--- a/cammy-rpy/cammylib/parser.py
+++ b/cammy-rpy/cammylib/parser.py
@@ -1,8 +1,11 @@
 from cammylib.sexp import sexp
 
 
-class CammyParser(object):
+class ParseError(Exception):
+    def __init__(self, message):
+        self.message = message
 
+class CammyParser(object):
     def __init__(self, s):
         self._i = 0
         self._s = s
@@ -10,8 +13,11 @@ class CammyParser(object):
     def position(self):
         return self._i
 
+    def hasMore(self):
+        return self._i < len(self._s)
+
     def eatWhitespace(self):
-        while self._i < len(self._s) and self._s[self._i] in (" ", "\n"):
+        while self.hasMore() and self._s[self._i] in (" ", "\n"):
             self._i += 1
 
     def canAndDoesEat(self, c):
@@ -23,7 +29,7 @@ class CammyParser(object):
 
     def takeName(self):
         start = self._i
-        while self._i < len(self._s) and self._s[self._i] not in (")", "(", " ", "\n"):
+        while self.hasMore() and self._s[self._i] not in (")", "(", " ", "\n"):
             self._i += 1
         stop = self._i
         return self._s[start:stop]
@@ -42,12 +48,15 @@ class CammyParser(object):
             return sexp.Atom(symbol)
 
     def startFunctor(self):
+        start = self._i
         head = self.takeName()
         self.eatWhitespace()
         args = []
         while not self.canAndDoesEat(')'):
             args.append(self.takeExpression())
             self.eatWhitespace()
+            if not self.hasMore():
+                raise ParseError("Unterminated functor starting at %d" % start)
         return sexp.Functor(head, args)
 
 

--- a/cammy-rpy/cammylib/types.py
+++ b/cammy-rpy/cammylib/types.py
@@ -6,6 +6,7 @@ class UnificationFailed(Exception):
 
 def occursCheck(index, var):
     "If an index occurs in a variable, raise an error."
+    # print "occurs check: does", index, "occur in", var.asStr()
     if var.occurs(index):
         raise UnificationFailed("Occurs check: %d in %s" %
                 (index, var.asStr()))
@@ -27,19 +28,23 @@ class ConstraintStore(object):
         rv = self.i
         self.i += 1
         self.constraints.append(sexp.Hole(rv))
+        # print "fresh", rv
         return rv
 
     def concrete(self, symbol):
         rv = self.i
         self.i += 1
         self.constraints.append(sexp.Atom(symbol))
+        # print "concrete", rv, "|->", symbol
         return rv
 
     def functor(self, constructor, arguments):
         rv = self.i
         self.i += 1
         args = [sexp.Hole(arg) for arg in arguments]
-        self.constraints.append(sexp.Functor(constructor, args))
+        functor = sexp.Functor(constructor, args)
+        self.constraints.append(functor)
+        # print "functor", rv, "|->", functor.asStr()
         return rv
 
     def walk(self, i):

--- a/cammy-rpy/repl.py
+++ b/cammy-rpy/repl.py
@@ -10,7 +10,7 @@ from cammylib.hive import Hive, MissingAtom
 from cammylib.djinn import askDjinn
 from cammylib.elements import T, N
 from cammylib.jelly import jellify
-from cammylib.parser import parse, parseTypes
+from cammylib.parser import parse, parseTypes, ParseError
 from cammylib.types import ConstraintStore, TypeExtractor, TypeFormatter, UnificationFailed
 
 LINE_BUFFER_LENGTH = 1024
@@ -137,10 +137,17 @@ def repl(hive, stdin, stdout):
         if line.startswith(":"):
             if len(line) < 2:
                 print "Not a full command"
-            command(hive, line[1], line[3:], context)
+            try:
+                command(hive, line[1], line[3:], context)
+            except ParseError as pe:
+                print "Parse error:", pe.message
             continue
         lineIsAtom = not line.startswith("(")
-        sexp, trail = parse(line)
+        try:
+            sexp, trail = parse(line)
+        except ParseError as pe:
+            print "Parse error:", pe.message
+            continue
         # Save the original expr for next time.
         mostRecentExpr = sexp
         try:

--- /dev/null
+++ b/hive/bool-sum.cammy
@@ -0,0 +1 @@
+(comp (pair/mapsnd either) (comp fun/distribr (sum/par fst fst)))
\ No newline at end of file

--- /dev/null
+++ b/hive/bool/ternary.cammy
@@ -0,0 +1 @@
+(comp (comp (fun/graph @0) (pair/mapsnd either)) (comp fun/distribr (case (comp fst @1) (comp fst @2))))
\ No newline at end of file

--- /dev/null
+++ b/hive/combinators/k.cammy
@@ -0,0 +1 @@
+(curry fst)
\ No newline at end of file

--- /dev/null
+++ b/hive/combinators/s.cammy
@@ -0,0 +1 @@
+(curry (curry (comp (pair (pair/of app fstfst snd) (pair/of app fstsnd snd)) app)))
\ No newline at end of file

--- /dev/null
+++ b/hive/combinators/w.cammy
@@ -0,0 +1 @@
+(curry (comp (pair app snd) app))
\ No newline at end of file

--- /dev/null
+++ b/hive/comonads/product/bind.cammy
@@ -0,0 +1 @@
+(pair fst @0)
\ No newline at end of file

--- /dev/null
+++ b/hive/comonads/reader/counit.cammy
@@ -0,0 +1 @@
+(pair/of app id (fun/const @0))
\ No newline at end of file

--- /dev/null
+++ b/hive/comonads/reader/duplicate.cammy
@@ -0,0 +1 @@
+(curry (curry (comp (pair snd (comp fst @0)) app)))
\ No newline at end of file

--- /dev/null
+++ b/hive/comonads/store/duplicate.cammy
@@ -0,0 +1 @@
+(pair (curry id) id)
\ No newline at end of file

--- /dev/null
+++ b/hive/hailstone.cammy
@@ -0,0 +1 @@
+(bool/ternary nat/even? (comp nat-div2 fst) (comp nat-mul3 succ))
\ No newline at end of file

--- /dev/null
+++ b/hive/list-choose.cammy
@@ -0,0 +1 @@
+(monad-choose monads/list/zero monads/list/unit monads/list/add)
\ No newline at end of file

--- /dev/null
+++ b/hive/list/flatmap.cammy
@@ -0,0 +1 @@
+(fold nil list/append)
\ No newline at end of file

--- /dev/null
+++ b/hive/list/kata.cammy
@@ -0,0 +1 @@
+(fold @0 @1)
\ No newline at end of file

--- /dev/null
+++ b/hive/list/para.cammy
@@ -0,0 +1 @@
+(comp (fold (pair nil @0) (pair (pair/of cons fst sndfst) @1)) snd)
\ No newline at end of file

--- /dev/null
+++ b/hive/list/tails.cammy
@@ -0,0 +1 @@
+(list/para (comp (pair (fun/const nil) nil) cons) (l (l fst sndfst) sndsnd))
\ No newline at end of file

--- /dev/null
+++ b/hive/monad-choose.cammy
@@ -0,0 +1 @@
+(fold @0 (comp (pair/mapfst @1) @2))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/state/join.cammy
@@ -0,0 +1 @@
+(curry (comp app app))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/subset/add.cammy
@@ -0,0 +1 @@
+(curry (comp (comp (pair (pair fstfst snd) (pair fstsnd snd)) (v2/map app)) disj))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/subset/guard.cammy
@@ -0,0 +1 @@
+(curry (comp swap snd))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/subset/join.cammy
@@ -0,0 +1 @@
+(curry (comp (pair app snd) app))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/subset/unit.cammy
@@ -0,0 +1 @@
+(curry @0)
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/subset/zero.cammy
@@ -0,0 +1 @@
+(fun/name (fun/const f))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/writer/join.cammy
@@ -0,0 +1 @@
+(pair fstfst (pair/of @0 fstsnd snd))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/writer/map.cammy
@@ -0,0 +1 @@
+(pair/mapfst @0)
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/writer/unit.cammy
@@ -0,0 +1 @@
+(pair id (fun/const @0))
\ No newline at end of file

--- /dev/null
+++ b/hive/monads/writer/write.cammy
@@ -0,0 +1 @@
+dup
\ No newline at end of file

--- /dev/null
+++ b/hive/monoids/add/add.cammy
@@ -0,0 +1 @@
+nat/add
\ No newline at end of file

--- /dev/null
+++ b/hive/monoids/add/zero.cammy
@@ -0,0 +1 @@
+zero
\ No newline at end of file

--- /dev/null
+++ b/hive/monoids/mul/add.cammy
@@ -0,0 +1 @@
+nat/mul
\ No newline at end of file

--- /dev/null
+++ b/hive/monoids/mul/zero.cammy
@@ -0,0 +1 @@
+nat/1
\ No newline at end of file

--- /dev/null
+++ b/hive/nat-div2.cammy
@@ -0,0 +1 @@
+(pr (pair zero f) (comp bool-sum (case (pair succ (fun/const f)) (pair id (fun/const t)))))
\ No newline at end of file

--- /dev/null
+++ b/hive/nat-mul3.cammy
@@ -0,0 +1 @@
+(pair/of nat/mul id (fun/const nat/3))
\ No newline at end of file

--- /dev/null
+++ b/hive/nat/kata.cammy
@@ -0,0 +1 @@
+(pr @0 @1)
\ No newline at end of file

--- a/hive/nat/para.cammy
+++ b/hive/nat/para.cammy
@@ -1 +1 @@
-(comp (pr (pair @0 zero) (pair @1 (comp snd succ))) fst)
\ No newline at end of file
+(comp (pr (pair zero @0) (pair (comp fst succ) @1)) snd)
\ No newline at end of file

--- /dev/null
+++ b/hive/poly/deriv.cammy
@@ -0,0 +1,12 @@
+(fold right
+  (comp
+    (comp
+      fun/distribr
+      (case
+        (pair
+          (comp sndfst succ)
+          (comp (comp pair/assl (pair/mapfst nat/mul)) cons))
+        (comp snd (pair nat/1 nil))))
+    left))
+
+The derivative of a polynomial, which itself is a polynomial.

--- /dev/null
+++ b/hive/poly/nice-deriv.cammy
@@ -0,0 +1 @@
+(comp poly/deriv (case snd nil))
\ No newline at end of file

--- /dev/null
+++ b/hive/subset-choose.cammy
@@ -0,0 +1 @@
+(monad-choose monads/subset/zero (monads/subset/unit @0) monads/subset/add)
\ No newline at end of file

--- /dev/null
+++ b/hive/subset-range.cammy
@@ -0,0 +1 @@
+(comp list/range (subset-choose nat/eq?))
\ No newline at end of file

--- /dev/null
+++ b/hive/swap-curry.cammy
@@ -0,0 +1 @@
+(curry (comp swap (uncurry @0)))
\ No newline at end of file

--- /dev/null
+++ b/hive/triang.cammy
@@ -0,0 +1 @@
+(comp (pair/of nat/mul id succ) (comp nat-div2 fst))
\ No newline at end of file

--- a/jelly/src/main.rs
+++ b/jelly/src/main.rs
@@ -121,8 +121,8 @@ fn main() -> std::io::Result<()> {
         rw!("swap-fst"; "(comp swap fst)" => "snd"),
         rw!("swap-snd"; "(comp swap snd)" => "fst"),
 
-        // This implies the old rule pair-swap-invo: (comp pair/swap pair/swap) => id
-        // So, like pair-swap-invo, this turns braided products into symmetric products.
+        rw!("pair-swap-invo"; "(comp swap swap)" => "id"),
+        // Like pair-swap-invo, this turns braided products into symmetric products.
         rw!("pair-swap-pair"; "(comp (pair ?f ?g) swap)" => "(pair ?g ?f)"),
 
         // free for left

--- a/movelist/test.json
+++ b/movelist/test.json
@@ -1,5 +1,6 @@
 [
     ["identity", "X", "X"],
+    ["K", "X", "(hom Y X)"],
     ["first component", "(pair X Y)", "X"],
     ["right unitor", "X", "(pair X 1)"],
     ["name of id", "1", "(hom X X)"],

--- a/todo.txt
+++ b/todo.txt
@@ -42,8 +42,6 @@
   * Maybe nat/ -> n/ for consistency with f/
     * bool/ -> b/ or bool -> 2/ ?
   * Predicates should have a trailing question mark
-    * e.g. nat/is_zero -> nat/zero?
-      * done
     * This means f-lt should be f-lt?
 * fun/name should always start from 1
   * Requires changing some callers
@@ -106,6 +104,7 @@
 * fun/precomp is an ingredient of CPS transformation
   * https://okmij.org/ftp/continuations/undelimited.html
 * It's about time to rewrite the multisampling logic in Cammy
+  * Mostly just needs pixel radius to be passed to image
 * Some basic dependent types
   * Type-level arithmetic would be nice
     * Could have types like (fin n): not just 1 and 2, but 3, 4, etc.
@@ -204,3 +203,102 @@
   * Multiple results: [X] -> [Y × [X]]
     * blends non-determinism and state
 * Render 3b1b's simple iterated Newton fractal
+* Lenses
+  * Given a category C...
+    * Lens(C): Objects are pairs X × Y, internal homs [X × Y, Z × W] are:
+      * [X, Y] × [X × W, Z]
+    * LinLens(C): Objects are pairs X × Y, internal homs [X × Y, Z × W] are:
+      * [X, Y × [W, Z]]
+    * Lens(C) and LinLens(C) are equivalent when C is Cartesian closed!
+      * Massage Lens(C) arrows to [X, Y] × [X, [W, Z]] by currying under the
+        second hom
+      * LinLens => Lens
+        * LinLens: Pass an X, get Y × [W, Z]
+        * Lens: Pass X to both sides of the pair, get Y × [W, Z]
+      * Lens => LinLens
+        * Same steps but inverse
+      * djinn can't handle these
+      * Further, Optic(C) or other generalized lenses are also equivalent
+* Profunctors
+  * Generalizes functors:
+    * Replace F : C -> D with
+    * F : C^ × D -> Set
+* (l nil nil) fails an occurs check
+  * Root cause: (comp nil dup) = (pair nil nil)
+    * Typechecker can't tell that the two nils are different types
+    * If jelly uses dup, then we get different typechecker results
+  * Workaround: (pair (fun/const nil) nil)
+    * jelly can't tell that (comp ignore nil) is superfluous here and doesn't
+      insert dup
+    * typechecker instantiates nil's RHS twice, doesn't unify them
+    * allows writing list/tails : [X] -> [[X]]
+* WTB interactive proof assistant
+  * I ask for an arrow X -> Y, specifying types X and Y
+  * If the arrow is universal, unwrap it somewhat and recurse
+  * Otherwise, prompt for me to make a choice
+    * I can choose an existing theorem from the hive and handle a premise
+    * I can craft a partial unwrapping and transform a premise
+    * I can introduce a given
+    * I can ask djinn for some possibilities
+    * I can add an invariant and ask for a simplification from jelly?
+* Metrics
+  * Euclidean
+  * Taxicab
+  * Maximum
+  * Lp
+* Deferreds
+  * Monad API
+    * Given x : 1 -> X, (seed x) : 1 -> DX
+    * Given f : X -> Y, (dmap f): DX -> DY
+    * Given a : X -> DY, (dchain m) : DX -> DY
+* IDE
+  * Smalltalk-ish list of recent expressions
+  * Each expression has a type
+  * IDE has templates which recognize types
+    * 1 -> F × (F × F) could be an element of F³, but also an RGB color
+    * Polymorphic arrows like X -> X could be natural transformations
+    * Rendering/viewing could be done per-template
+      * Colors could be shown with swatches in the recent-expression list
+      * Images and videos could be thumbnailed, previewed, etc.
+* Priority queues
+  * Given min : X × X -> X
+    * findMin : Q -> X + 1
+    * insert : X x Q -> Q
+    * meld : Q × Q -> Q
+    * deleteMin: Q -> Q + 1
+    * empty : 1 -> Q
+    * empty? : Q -> 2
+    * (comp (comp (pair @0 (fun/const empty)) insert) findMin) == (comp @0 left)
+* An optimized natset: [N] × N × [N, 2]
+  * The idea is that it's just [N, 2], but with a memoizing cache
+  * The list stores all of the members
+  * The lone nat is the lower bound for what's been checked so far
+  * (ns, k, f) where ns = { f(n) | n < k }
+* Isomorphisms
+  * CCC isos are fully characterized by a list of axioms
+    * https://en.wikipedia.org/wiki/Cartesian_closed_category#Equational_theory
+    * Also gives a partial listing of BCCC isos (CCCs with sums)
+  * Motivation: isos are useful objects, but our theories can't prove that
+    user-provided arrows are iso
+    * Makes sense, without access to universe types or NTs
+    * OTOH, every polymorphic arrow is an NT already
+      * And so every polymorphic iso would be a natural iso... There's
+        something here, but I'm not sure what yet
+    * Would monics and epics also be useful?
+      * Being monic or epic is a property, but being iso is structure
+      * Category of isos is always groupoid, for example
+* Double recursion
+  * G(0) = \x -> x + 1
+  * G(n + 1) = \x -> case x of
+    zero -> G(n)(1)
+    x + 1 -> G(n)(G(n + 1)(x))
+* Generalized induction schemes
+  * Using lists as an example...
+    * We should have a way to incrementally assemble lists
+      * cons : X × [X] -> [X]
+    * And also a way to incrementally eliminate them
+      * uncons : [X] -> X × [X] + 1
+    * And these should be adjoint
+      * (comp cons uncons) = left : X × [X] -> X × [X] + 1
+      * (comp uncons (case cons nil)) = id : [X] -> [X]
+    * This all suggests that we should automatically generate uncons