dsl-tools -> raddsl

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Peter Sovietov.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,2 +1,3 @@
-# dsl-tools
-Tools for rapid prototyping of DSL compilers
+# raddsl
+
+Tools for rapid prototyping of DSL compilers.

examples/calc/calc.py

@@ -0,0 +1,19 @@
+# calc
+
+from raddsl.rewrite import *
+from calc_parser import parse, Int, BinOp
+
+X, Y = let(X=id), let(Y=id)
+
+calc_rules = alt(
+  Int(id),
+  rule(BinOp("+", Int(X), Int(Y)), to(lambda v: Int(v.X + v.Y))),
+  rule(BinOp("-", Int(X), Int(Y)), to(lambda v: Int(v.X - v.Y))),
+  rule(BinOp("*", Int(X), Int(Y)), to(lambda v: Int(v.X * v.Y))),
+  rule(BinOp("/", Int(X), Int(Y)), to(lambda v: Int(v.X // v.Y)))
+)
+
+def calc(src):
+  t = Tree(parse(src))
+  bottomup(calc_rules)(t)
+  return t.out

examples/calc/calc_parser.py

@@ -0,0 +1,46 @@
+# calc
+
+from raddsl.parse import *
+
+make_term = lambda t: lambda *a: (t,) + a
+
+Int = make_term("Int")
+Op = make_term("Op")
+BinOp = make_term("BinOp")
+
+tok_op = to(1, Op)
+tok_none = to(0, lambda: None)
+tok_num = to(1, lambda x: Int(int(x)))
+
+ws = seq(some(space), tok_none)
+num = seq(quote(some(digit)), tok_num)
+oper = seq(quote(one_of("+-*/()")), tok_op)
+tokens = seq(many(alt(ws, oper, num)), end)
+
+op = lambda o: eat(lambda x: x == ("Op", o))
+val = lambda x: x[1] if x[0] == "Op" else x[0]
+
+ast_bop = to(3, lambda x, o, y: BinOp(o[1], x, y))
+left_bop = lambda b: seq(push(id), expr(b + 1), ast_bop)
+
+expr = tdop(lambda x: prefix.get(val(x)), lambda x: infix.get(val(x)))
+
+prefix = {
+  "Int": push(id),
+  "(": seq(id, expr(0), op(")"))
+}
+
+infix = {
+  "+": (left_bop, 10),
+  "-": (left_bop, 10),
+  "*": (left_bop, 20),
+  "/": (left_bop, 20)
+}
+
+def scan(src):
+  s = Stream(src)
+  return [x for x in s.out if x] if tokens(s) else []
+
+def parse(src):
+  s = Stream(scan(src))
+  return s.out[0] if expr(0)(s) else []

halt.py → examples/halt/halt.py

@@ -3,7 +3,7 @@
 
 from random import randint
 from halt_parser import parse
-from lib.dsl_match import *
+from raddsl.rewrite import *
 
 A = let(A=id)
 B = let(B=id)

halt_parser.py → examples/halt/halt_parser.py

@@ -1,7 +1,7 @@
 # Halting Problem
 # https://www.reddit.com/r/dailyprogrammer/comments/1euacb/052213_challenge_125_intermediate_halt_its/
 
-from lib.dsl_parse import *
+from raddsl.parse import *
 
 ws = many(space)
 number = seq(ws, quote(some(digit)), to(1, int))

json_parser.py → examples/json/json_parser.py

@@ -1,6 +1,6 @@
 # JSON parser
 
-from lib.dsl_parse import *
+from raddsl.parse import *
 
 token = lambda tag: to(1, lambda x: (tag, x))
 token_num = to(1, lambda x: ("num", float(x)))
@@ -14,12 +14,11 @@
 uhex = alt(digit, range_of("a", "f"), range_of("A", "F"))
 uXXXX = seq(a("u"), uhex, uhex, uhex, uhex)
 escaped = seq(a("\\"), alt(one_of('"\\/bfnrt'), uXXXX))
-string = seq(
-  a('"'), quote(many(alt(non(one_of('"\\')), escaped))), a('"'), token("str")
-)
+string = seq(a('"'), quote(many(alt(non(one_of('"\\')), escaped))),
+  a('"'), token("str"))
 tokens = seq(many(seq(ws, alt(operator, string, number))), ws, end)
 
-op = lambda n: eat(lambda x: x[0] == "op" and x[1] == n)
+op = lambda o: eat(lambda x: x == ("op", o))
 tok = lambda t: seq(push(eat(lambda x: x[0] == t)), to(1, lambda x: x[1]))
 true = seq(op("true"), to(0, lambda: True))
 false = seq(op("false"), to(0, lambda: False))
@@ -31,16 +30,10 @@
 value = alt(tok("num"), tok("str"), true, false, null, obj, array)
 json = alt(obj, array)
 
-def scan(source):
-  s = Stream(source)
+def scan(src):
+  s = Stream(src)
   return s.out if tokens(s) else []
 
-def parse(source):
-  s = Stream(scan(source))
+def parse(src):
+  s = Stream(scan(src))
   return s.out[0] if json(s) else []
-
-source = """
-{ "Object":{"Zoom": false, "Property1":{"Property2":{"Color":[0,153,255,0]},"Width":40}} }
-"""
-
-print(parse(source))

pl0.py → examples/pl0/pl0.py

@@ -1,37 +1,37 @@
 # PL/0
 
-from lib.dsl_match import *
+from raddsl.rewrite import *
 from pl0_parser import parse
 from pl0_term import *
 
 TAB = " " * 4
 
-PRELUDE = """class Mem:
-  pass
+PRELUDE = """
+class Mem:
+    pass
 M = Mem()
 def read():
-  return int(input())
+    return int(input())
 def write(x):
-  print(x)"""
+    print(x)
+""".strip()
 
-X = let(X=id)
-Y = let(Y=id)
-Z = let(Z=id)
+X, Y, Z = let(X=id), let(Y=id), let(Z=id)
 
 def emit(t):
   if t.out:
     t.code.append(TAB * t.level + t.out)
   return True
 
-def indent(t):
-  t.level += 1
-  return True
-
-def dedent(t):
-  t.level -= 1
-  return True
+def indent(f):
+  def walk(t):
+    t.level += 1
+    m = f(t)
+    t.level -= 1
+    return m
+  return walk
 
-ident = rule(Id(X), to(lambda v: "M.%s" % v.X))
+name = rule(Id(X), to(lambda v: "M.%s" % v.X))
 num = rule(Num(X), to(lambda v: "%s" % v.X))
 
 def trans_op(x):
@@ -44,34 +44,32 @@ def trans_op(x):
   rule(Binop(X, Y, Z), to(lambda v: "(%s %s %s)" % (v.Y, trans_op(v.X), v.Z))),
   rule(Unop("odd", Y), to(lambda v: "(%s & 1 != 0)" % v.Y)),
   rule(Unop(X, Y), to(lambda v: "%s%s" % (v.X, v.Y))),
-  ident,
+  name,
   num
 ))
 
 var = seq(Var(id), build(lambda v: Line("")))
 
 pair = rule(
-  [let(X=ident), let(Y=num)], to(lambda v: Line("%s = %s" % (v.X, v.Y)))
+  [let(X=name), let(Y=num)], to(lambda v: Line("%s = %s" % (v.X, v.Y)))
 )
 
 const = rule(Const(let(X=each(pair))), to(lambda v: v.X))
 
 block = delay(lambda: block)
-
 proc = rule(
   Proc(X, let(Y=block)), to(lambda v: [Line("def %s():" % v.X[1]), Tab(v.Y)])
 )
 
 stmt = delay(lambda: stmt)
-
 stmt = alt(
   rule(
-    Assign(let(X=ident), let(Y=expr)),
+    Assign(let(X=name), let(Y=expr)),
     to(lambda v: Line("%s = %s" % (v.X, v.Y)))
   ),
   rule(Call(X), to(lambda v: Line("%s()" % v.X[1]))),
-  rule(Read(let(X=ident)), to(lambda v: Line("%s = read()" % v.X))),
-  rule(Write(let(X=ident)), to(lambda v: Line("write(%s)" % v.X))),
+  rule(Read(let(X=name)), to(lambda v: Line("%s = read()" % v.X))),
+  rule(Write(let(X=name)), to(lambda v: Line("write(%s)" % v.X))),
   rule(Begin(let(X=each(stmt))), to(lambda v: v.X)),
   rule(
     If(let(X=expr), let(Y=stmt)),
@@ -81,16 +79,15 @@ def trans_op(x):
     While(let(X=expr), let(Y=stmt)),
     to(lambda v: [Line("while %s:" % v.X), Tab(v.Y)])
   ),
-  seq(Nop(), build(lambda v: Line("pass")))
+  rule(Nop(), build(lambda v: Line("pass")))
 )
 
 block = rule(
   Block(let(X=each(alt(var, const, proc, stmt)))), to(lambda v: v.X)
 )
 
 gen = delay(lambda: gen)
-
-gen = alt(Tab(seq(indent, gen, dedent)), Line(emit), each(gen))
+gen = alt(Tab(indent(gen)), Line(emit), each(gen))
 
 def trans(source):
   ast = parse(source)
@@ -100,7 +97,3 @@ def trans(source):
   if seq(block, gen)(t):
     return "\n".join(t.code)
   return None
-
-with open("primes.pl0") as f:
-  source = f.read()
-print(trans(source))

pl0_ast.py → examples/pl0/pl0_ast.py

@@ -1,6 +1,6 @@
 # PL/0
 
-from lib.dsl_parse import *
+from raddsl.parse import *
 from pl0_term import *
 
 def parse_expr(rest):

pl0_parser.py → examples/pl0/pl0_parser.py

@@ -1,6 +1,6 @@
 # PL/0
 
-from lib.dsl_parse import *
+from raddsl.parse import *
 import pl0_ast as ast
 
 token = lambda tag: to(1, lambda x: (tag, x))
@@ -18,7 +18,7 @@
 tag = lambda t: push(eat(lambda x: x[0] == t))
 ident = tag("id")
 number = tag("num")
-op = lambda n: eat(lambda x: x[0] == "op" and x[1] == n)
+op = lambda n: eat(lambda x: x == ("op", n))
 expression = lambda x: expression(x)
 factor = alt(ident, number, seq(op("("), expression, op(")")))
 term = seq(group(list_of(factor, push(alt(op("*"), op("/"))))), ast.expr)
@@ -55,12 +55,10 @@
 block = seq(group(opt(const), opt(var), many(procedure), statement), ast.block)
 program = seq(block, op("."))
 
-def scan(source):
-  s = Stream(source)
-  if not tokens(s):
-    return []
-  return [x for x in s.out if x is not None]
+def scan(src):
+  s = Stream(src)
+  return [x for x in s.out if x] if tokens(s) else []
 
-def parse(source):
-  s = Stream(scan(source))
+def parse(src):
+  s = Stream(scan(src))
   return s.out[0] if program(s) else []

pl0_term.py → examples/pl0/pl0_term.py

@@ -1,6 +1,6 @@
 # PL/0
 
-make_term = lambda tag: lambda *args: (tag,) + args
+make_term = lambda t: lambda *a: (t,) + a
 
 Id = make_term("id")
 Num = make_term("num")

examples/prop/prop.py

@@ -0,0 +1,57 @@
+# prop
+# http://releases.strategoxt.org/strategoxt-manual/strategoxt-manual-0.17pre18708-z74k09nh/manual/one-page/index.html
+
+from raddsl.rewrite import *
+
+X, Y = let(X=id), let(Y=id)
+
+make_term = lambda t: lambda *a: (t,) + a
+
+Atom = make_term("Atom")
+T = make_term("T")
+F = make_term("F")
+And = make_term("And")
+Or = make_term("Or")
+Not = make_term("Not")
+Impl = make_term("Impl")
+Eq = make_term("Eq")
+
+eval_rules = alt(
+  rule(Not(T()), to(lambda v: F())),
+  rule(Not(F()), to(lambda v: T())),
+  rule(And(T(), X), to(lambda v: v.X)),
+  rule(And(X, T()), to(lambda v: v.X)),
+  rule(And(F(), X), to(lambda v: F())),
+  rule(And(X, F()), to(lambda v: F())),
+  rule(Or(T(), X), to(lambda v: T())),
+  rule(Or(X, T()), to(lambda v: T())),
+  rule(Or(F(), X), to(lambda v: v.X)),
+  rule(Or(X, F()), to(lambda v: v.X)),
+  rule(Impl(T(), X), to(lambda v: v.X)),
+  rule(Impl(X, T()), to(lambda v: T())),
+  rule(Impl(F(), X), to(lambda v: T())),
+  rule(Eq(F(), X), to(lambda v: Not(v.X))),
+  rule(Eq(X, F()), to(lambda v: Not(v.X))),
+  rule(Eq(T(), X), to(lambda v: v.X)),
+  rule(Eq(X, T()), to(lambda v: v.X))
+)
+
+eval_prop = bottomup(repeat(eval_rules))
+
+DefN = rule(Not(X), to(lambda v: Impl(v.X, F())))
+DefI = rule(Impl(X, Y), to(lambda v: Or(Not(v.X), v.Y)))
+DefE = rule(Eq(X, Y), to(lambda v: And(Impl(v.X, v.Y), Impl(v.Y, v.X))))
+DefO1 = rule(Or(X, Y), to(lambda v: Impl(Not(v.X), v.Y)))
+DefO2 = rule(Or(X, Y), to(lambda v: Not(And(Not(v.X), Not(v.Y)))))
+DefA1 = rule(And(X, Y), to(lambda v: Not(Or(Not(v.X), Not(v.Y)))))
+DefA2 = rule(And(X, Y), to(lambda v: Not(Impl(v.X, Not(v.Y)))))
+IDefI = rule(Or(Not(X), Y), to(lambda v: Impl(v.X, v.Y)))
+IDefE = rule(And(Impl(X, Y), Impl(Y, X)), to(lambda v: Eq(v.X, v.Y)))
+
+desugar = topdown(opt(alt(DefI, DefE)))
+impl_nf = topdown(repeat(alt(DefN, DefA2, DefO1, DefE)))
+
+def prop_test():
+  t = Tree(And(Impl(T(), And(Atom("p"), Atom("q"))), Atom("p")))
+  seq(desugar, eval_prop)(t)
+  return t.out

examples/test.py

@@ -0,0 +1,3 @@
+import doctest
+
+doctest.testfile("test.txt")