提交: 7a65a2ad61556360b675678d99db2c2a3599afb8 - cammy (git)

A categorical programming language

Commit MetaInfo

• 修订版: 7a65a2ad61556360b675678d99db2c2a3599afb8 (tree)
• 时间: 2022-02-18 14:32:04
• 作者: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Split cammy-run into cammy-draw and pieces.

The parser and arrow-builder are now in their own module, so that both
cammy-draw and cammy-repl can use them. cammy-draw is finally around the
proper size, carrying proper responsibilities.

更改概述

• add: cammy-rpy/cammylib/parser.py
• add: cammy-rpy/cammylib/sexp.py
• delete: cammy-rpy/default.nix
• modified: cammy-rpy/repl.py
• delete: cammy-rpy/{main.py => cammylib/arrows.py}
• modified: default.nix
• modified: shell.nix
• modified: todo.txt

差异

--- a/cammy-rpy/main.py
+++ b/cammy-rpy/cammylib/arrows.py
@@ -1,13 +1,10 @@
+import math
 
-import math, sys
-
-from rpython.rlib.jit import JitDriver, isconstant, set_param, unroll_safe, we_are_jitted
+from rpython.rlib.jit import JitDriver, isconstant, we_are_jitted
 from rpython.rlib.rbigint import rbigint
-from rpython.rlib.rfloat import string_to_float
-from rpython.rlib.rstring import StringBuilder, split
 
-from cammylib.hax import patch_ctypes_for_ffi
-from cammylib import stb
+from cammylib.parser import Atom, Functor
+
 
 class TypeFail(Exception):
     def __init__(self, reason):
@@ -395,161 +392,15 @@ def buildCompound(name, args):
     else:
         raise BuildProblem("Invalid compound functor: " + name)
 
-
-class CammyParser(object):
-
-    def __init__(self, s):
-        self._i = 0
-        self._s = s
-
-    def eatWhitespace(self):
-        while self._i < len(self._s) and self._s[self._i] in (" ", "\n"):
-            self._i += 1
-
-    def canAndDoesEat(self, c):
-        if self._s[self._i] == c:
-            self._i += 1
-            return True
-        else:
-            return False
-
-    def takeName(self):
-        start = self._i
-        while self._i < len(self._s) and self._s[self._i] not in (")", "(", " ", "\n"):
-            self._i += 1
-        stop = self._i
-        return self._s[start:stop]
-
-    def takeExpression(self):
-        self.eatWhitespace()
-        if self.canAndDoesEat('('):
-            return self.startFunctor()
-        else:
-            return buildUnary(self.takeName())
-
-    def startFunctor(self):
-        head = self.takeName()
-        self.eatWhitespace()
-        args = []
-        while not self.canAndDoesEat(')'):
-            args.append(self.takeExpression())
-        return buildCompound(head, args)
-
-
-def parse(s):
+def buildArrow(sexp):
     try:
-        return CammyParser(s).takeExpression()
+        if isinstance(sexp, Atom):
+            return buildUnary(sexp.symbol)
+        elif isinstance(sexp, Functor):
+            args = [buildArrow(arg) for arg in sexp.arguments]
+            return buildCompound(sexp.constructor, args)
+        else:
+            assert False, "inconceivable"
     except BuildProblem as bp:
-        print "Couldn't parse Cammy expression:", bp.message
-
-
-# Borrowed from stub.scm and Typhon's colors.mt
-
-def scale(bot, top, x):
-    d = top - bot
-    return bot + d * x
-
-def linear2sRGB(u):
-    try:
-        return u * 25 / 323 if u <= 0.04045 else math.pow((u * 200 + 11) / 211, 12 / 5)
-    except OverflowError:
-        return 1.0
-
-def finishChannel(c):
-    return int(255 * max(0.0, min(1.0, linear2sRGB(c))))
-
-# Pixel area: 4 / (w * h)
-# Pixel radius: √(area / pi) = 2 / √(w * h * pi) = (2 / √pi) / √(w * h)
-# This constant is the first half of that.
-TWOSQRTPI = 2.0 / math.sqrt(math.pi)
-
-class Window(object):
-    _immutable_ = True
-
-    def __init__(self, corners, width, height):
-        self._corners = corners[0], corners[1], corners[2], corners[3]
-        self._w = width
-        self._h = height
-        area = abs((corners[0] - corners[2]) * (corners[1] - corners[3]))
-        self.pixelRadius = TWOSQRTPI * area / math.sqrt(width * height)
-
-    def coordsForPixel(self, i):
-        w = i % self._w
-        h = i // self._w
-        iw = 1.0 / self._w
-        dw = 0.5 * iw
-        ih = 1.0 / self._h
-        dh = 0.5 * ih
-        c1 = scale(self._corners[0], self._corners[2], dw + iw * w)
-        c2 = scale(self._corners[1], self._corners[3], dh + ih * h)
-        return c1, c2
-
-sample_driver = JitDriver(name="sample",
-        greens=["program"], reds=["x", "y"],
-        is_recursive=True)
-
-def sample(program, x, y):
-    sample_driver.jit_merge_point(program=program, x=x, y=y)
-    rgb = program.run(P(F(x), F(y)))
-    r = rgb.first().f()
-    g = rgb.second().first().f()
-    b = rgb.second().second().f()
-    return r, g, b
-
-offsets = [(0.0, 0.0), (1.0, 1.0), (1.0, -1.0), (-1.0, 1.0), (-1.0, -1.0)]
-
-@unroll_safe
-def multisample(program, radius, x, y):
-    r = g = b = 0.0
-    for ox, oy in offsets:
-        sr, sg, sb = sample(program, x + radius * ox, y + radius * oy)
-        r += sr
-        g += sg
-        b += sb
-    l = len(offsets)
-    return finishChannel(r / l), finishChannel(g / l), finishChannel(b / l)
-
-def drawPixels(size, program, window):
-    sb = StringBuilder()
-    i = 0
-    while i < size:
-        c1, c2 = window.coordsForPixel(i)
-        r, g, b = multisample(program, window.pixelRadius, c1, c2)
-        sb.append(chr(r) + chr(g) + chr(b))
-        i += 1
-    return sb.build()
-
-def drawPNG(program, filename, corners, width, height):
-    window = Window(corners, width, height)
-    size = width * height
-    buf = drawPixels(size, program, window)
-    channels = 3
-    stb.i_write_png(filename, width, height, channels, buf, width * channels)
-
-
-def main(argv):
-    set_param(None, "trace_limit", 50001)
-
-    prog = argv[1]
-    window = [string_to_float(s) for s in split(argv[2])]
-    width = int(argv[3])
-    height = int(argv[4])
-    out = argv[5]
-    with open(prog) as handle:
-        func = parse(handle.read())
-    try:
-        drawPNG(func, out, window, width, height)
-    except TypeFail as tf:
-        print "Type failure:", tf.reason
+        print "Couldn't find Cammy expression:", bp.message
         raise
-    return 0
-
-
-def target(driver, *args):
-    patch_ctypes_for_ffi()
-    driver.exe_name = "cammy-run"
-    return main, None
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))

--- /dev/null
+++ b/cammy-rpy/cammylib/parser.py
@@ -0,0 +1,53 @@
+from cammylib.sexp import Atom, Functor
+
+
+class CammyParser(object):
+
+    def __init__(self, s):
+        self._i = 0
+        self._s = s
+
+    def position(self):
+        return self._i
+
+    def eatWhitespace(self):
+        while self._i < len(self._s) and self._s[self._i] in (" ", "\n"):
+            self._i += 1
+
+    def canAndDoesEat(self, c):
+        if self._s[self._i] == c:
+            self._i += 1
+            return True
+        else:
+            return False
+
+    def takeName(self):
+        start = self._i
+        while self._i < len(self._s) and self._s[self._i] not in (")", "(", " ", "\n"):
+            self._i += 1
+        stop = self._i
+        return self._s[start:stop]
+
+    def takeExpression(self):
+        self.eatWhitespace()
+        if self.canAndDoesEat('('):
+            return self.startFunctor()
+        else:
+            return Atom(self.takeName())
+
+    def startFunctor(self):
+        head = self.takeName()
+        self.eatWhitespace()
+        args = []
+        while not self.canAndDoesEat(')'):
+            args.append(self.takeExpression())
+        return Functor(head, args)
+
+
+def parse(s):
+    parser = CammyParser(s)
+    sexp = parser.takeExpression()
+    # Parser is now fast-forwarded to the end of the S-expression, so we can
+    # slice from that point and get the docstring/etc.
+    trail = s[parser.position():]
+    return sexp, trail

--- /dev/null
+++ b/cammy-rpy/cammylib/sexp.py
@@ -0,0 +1,19 @@
+class SExp(object):
+    "An S-expression."
+
+class Atom(SExp):
+    "An S-expression atom."
+
+    _immutable_fields_ = "symbol",
+
+    def __init__(self, symbol):
+        self.symbol = symbol
+
+class Functor(SExp):
+    "A list of S-expressions with a distinguished head."
+
+    _immutable_fields_ = "constructor", "arguments[:]",
+
+    def __init__(self, constructor, arguments):
+        self.constructor = constructor
+        self.arguments = arguments

--- a/cammy-rpy/default.nix
+++ /dev/null
@@ -1,5 +0,0 @@
-{ nixpkgs ? import <nixpkgs> {} }:
-let
-  makeBuilder = import ./builder.nix { inherit nixpkgs; };
-in
-  makeBuilder ./main.py "cammy-run" true

--- a/cammy-rpy/repl.py
+++ b/cammy-rpy/repl.py
@@ -2,20 +2,35 @@
 
 from rpython.rlib.rfile import create_stdio
 
+from cammylib.arrows import buildArrow, BuildProblem
+from cammylib.parser import parse
+
 LINE_BUFFER_LENGTH = 1024
 
 def repl(stdin, stdout):
     while True:
         stdout.write("> ")
         line = stdin.readline(LINE_BUFFER_LENGTH)
-        print line
+        if not line:
+            # Empty read means EOF.
+            break
+        sexp, trail = parse(line)
+        print "Got:", line
+        print "S-expression:", sexp
+        print "Trail:", trail
+        try:
+            arrow = buildArrow(sexp)
+            print "Arrow:", arrow
+        except BuildProblem as bp:
+            print "Couldn't build arrow:", bp.message
+    return 0
 
 def main(argv):
     stdin, stdout, stderr = create_stdio()
     try:
-        repl(stdin, stdout)
+        return repl(stdin, stdout)
     except:
-        return 0
+        return 1
 
 def target(driver, *args):
     driver.exe_name = "cammy-repl"

--- a/default.nix
+++ b/default.nix
@@ -4,7 +4,7 @@ let
   frame = import ./frame { inherit nixpkgs; };
   jelly = (import jelly/Cargo.nix { pkgs = nixpkgs; }).rootCrate.build;
   movelist = import ./movelist { inherit nixpkgs; };
-  cammy-run = import ./cammy-rpy { inherit nixpkgs; };
+  cammy-draw = import ./cammy-rpy/draw.nix { inherit nixpkgs; };
   cammy-repl = import ./cammy-rpy/repl.nix { inherit nixpkgs; };
   eggs = builtins.attrValues (removeAttrs (import ./eggs.nix {
     inherit pkgs;
@@ -46,7 +46,7 @@ in pkgs.stdenv.mkDerivation {
 
     makeWrapper ${movelist}/bin/movelist $out/bin/cammy-movelist
 
-    makeWrapper ${cammy-run}/bin/cammy-run $out/bin/cammy-draw
+    makeWrapper ${cammy-draw}/bin/cammy-draw $out/bin/cammy-draw
     makeWrapper ${cammy-repl}/bin/cammy-repl $out/bin/cammy-repl
   '';
 }

--- a/shell.nix
+++ b/shell.nix
@@ -17,6 +17,10 @@ in pkgs.stdenv.mkDerivation {
     egg2nix
     # maintaining frame/
     ocamlformat
+    # maintaining cammy-rpy/
+    pythonPackages.pyflakes
+    # using cammy-repl
+    rlwrap
     # working with sexps
     ocamlPackages.sexp
     # benchmarking

--- a/todo.txt
+++ b/todo.txt
@@ -44,3 +44,7 @@
   * Interval type?
 * Cantor's type of bitstrings: N -> 2
 * The square type: For a type X, 2 -> X
+* The double type: For a type X, X + X
+* Moore machines: For state type Q and input type S, Q × S -> Q
+  * 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