Commit: bf529a68c1fdcf1d1d3e210503e1acd3371ab4c8 - cammy (git)

A categorical programming language

Commit MetaInfo

• Revision: bf529a68c1fdcf1d1d3e210503e1acd3371ab4c8 (tree)
• Time: 2022-12-17 03:08:25
• Author: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Diagram how the tools interact.

Change Summary

• modified: shell.nix
• modified: todo.txt
• add: tools.dot

Incremental Difference

--- a/shell.nix
+++ b/shell.nix
@@ -52,6 +52,8 @@ in pkgs.stdenv.mkDerivation {
     ranger
     # Honey
     python39Packages.flask purescript
+    # Documentation
+    graphviz
     # experimenting with Honey
     wabt binaryen
     # openapi-generator-cli yaml2json python3Packages.virtualenv

--- a/todo.txt
+++ b/todo.txt
@@ -88,6 +88,7 @@
   * Might not be feasible unless we switch to stricter monoidal categories
     * We'd need an equivalence X × 1 → X
     * swap and dup would need to be primitive again too
+      * Done
 * Prove that nat/add is smallest with its behavior
   * Would justify its jet, since no smaller expression could be jetted
 * Streams
@@ -97,9 +98,6 @@
     * Creates a stream+maybe monad: X → [N, X + 1]
 * Subtypes?
   * Interval type?
-* Cantor's type of bitstrings: N -> 2
-  * We have subobjects now, X -> 2
-  * And finite bitstrings, [2]
 * Moore machines: For state type Q and input type S, Q × S -> Q
   * Suppose we have output/observation type O and Q -> O
     * Then Moore machines are equivalent to compact encodings [S] -> O
@@ -110,7 +108,9 @@
 * 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.
-* ulimit jellification?
+  * Motivations?
+    * Might be nice to build smaller subsets of the language ala carte
+      * Might allow coinductive types on top of that smaller subset!
 * formal power series N -> Q
   * needs Q
   * done for N -> N
@@ -126,9 +126,6 @@
     * Would not be fast enough for raytracing, but could generate various
       computable real constants
       * Extraction to floats would hopefully require n < 100
-* CI: automatic generation of demo images
-  * Would be nice to know how long it takes, too
-  * Parameterize by number of iterations?
 * 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
@@ -173,8 +170,9 @@
       * (uncurry @0) could be defined as (comp (pair/mapfst @0) fun/app)
   * list/uncons
     * has particularly simple bytecode, becoming a term op
-* Missing optimization
+* Missing optimizations
   * (comp f-log1p f-exp) => (comp (pair (fun/const f-one) id) f/add)
+    * Valid but not needed yet
 * Lentz's algorithm
   * https://en.wikipedia.org/wiki/Lentz's_algorithm
 * What's a parser again?
@@ -221,6 +219,13 @@
     * I can introduce a given
     * I can ask djinn for some possibilities
     * I can add an invariant and ask for a simplification from jelly?
+  * Could prototype in Honey: tile asks for two types using existing djinn syntax
+    * Backend calls something like djinn
+      * Not just a list of candidates, but also a determination of strategies
+        * If input is one of several base cases: something like X -> X, return id
+        * If monomorphic: Something like F × F -> F, return hardcoded candidates
+      * Should also take constraints
+        * Some constraints are powerful enough to give solutions like (pr ...)
 * Metrics
   * Euclidean
   * Taxicab
@@ -293,6 +298,9 @@
 * More recurrence relations
   * Cobalancing numbers: x_n+1 = 6x_n - x_n-1 + 2, x0 = 0, x1 = 2
     * Requires subtraction, multiple prior elements, multiple starting points
+* More series
+  * n: floor(n! / e) is always even
+    * All of the pieces should be available
 * Non-empty lists form a comonad
 * Moore machines form a comonad?
 * Ints
@@ -310,36 +318,7 @@
   * Still useful for e.g. equivalence relations
   * Another option is multivalued functions: [X, [Y]] × [Y, [X]]
     * Composition would be done in the list/set monad
-* Honey: Web browser 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.
-    * Sees a type like [X] -> ... and calls it "a natural transformation from
-      lists to ..."
-    * Types like X -> 2 are called "predicates on X"
-    * Suggests some sort of recursive templating structure
-    * Demo works for static images, sequences, elements, videos
-  * Honey API
-    * Let's write OpenAPI for this and use a generator
-      * I'm just so fucking tired of doing boilerplate by hand
-      * Done; seems like Flask servers and OCaml clients can be generated!
-  * Let's draw an animation on a canvas
-    * Everything is set up, but it doesn't work
-      * demo/mandelbrot takes a long time to render, probably
-      * draw/complex-fun is less clear; even rendering the identity function
-        is interesting, usually
-  * Interactive entry of new Cammy programs
-    * First plan: send S-expression from textbox to Python server
-      * Parse in Python
-      * Expand relative to hive in Python
-      * Typecheck as usual
-      * Return heap token
-      * Done! Works!
+      * Needs equality in order to avoid duplicates
 * Voronoi diagrams
   * Take a list of points and our input point
   * Fold over the list to find the nearest point to the input
@@ -392,13 +371,7 @@
   * Let's rewrite Honey with FastAPI!
     * And use PyPy!
     * But not right now!
-  * Let's compile Cammy to JS using PureScript!
-    * This is feasible; set up a stub and then compile
-      * Done! But it is not especially faster
 * Slogans?
   * Cammy is compositional
   * Cammy is chimeric
   * Cammy is category-theoretic
-* More series
-  * n: floor(n! / e) is always even
-    * All of the pieces should be available

--- /dev/null
+++ b/tools.dot
@@ -0,0 +1,7 @@
+digraph tools {
+  Cammy -> Cammy [label="jelly"];
+  Cammy -> WAT [label="cammy-wasm"];
+  Cammy -> PNG [label="cammy-draw"];
+  Cammy -> Types [label="cammy-type"];
+  Types -> Cammy [label="cammy-djinn"];
+}