Merge pull request #245 from rolyp/primitive-id

Index of primitive results depend only on arguments, not calling context. Underscore patterns.
explorable-viz · Nov 2, 2019 · 5eb01ba · 5eb01ba
2 parents a96b57a + f3012bb
commit 5eb01ba
Show file tree

Hide file tree

Showing 10 changed files with 34 additions and 17 deletions.
diff --git a/fluid/example/mergeSort.fld b/fluid/example/mergeSort.fld
@@ -2,14 +2,14 @@ letrec
    fun split {
       [] → ([], []);
       [x, ...xs] →
-         match split xs as 
+         match split xs as
             (ys, zs) → ([x, ...zs], ys)
    };
 
    fun merge xs ys →
       match (xs, ys) as {
-         ([], ys') → ys;
-         ([x, ...xs'], []) → xs;
+         ([], _) → ys;                               
+         ([x, ...xs'], []) → xs;                   
          ([x, ...xs'], [y, ...ys']) →
             match x < y as {
                True → [x, ...merge xs' ys];
@@ -21,7 +21,7 @@ letrec
       match xs as {
          [] → xs;
          [x] → xs;
-         [x, y, ...xs'] →
+         [x, y, ..._] →
             match split xs as 
                (ys, zs) → merge (mergesort ys) (mergesort zs)
       }

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@rolyp/fluid",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Fluid",
   "dependencies": {
     "@types/three": "0.93.28",

diff --git a/src/Eval.ts b/src/Eval.ts
@@ -192,7 +192,8 @@ export function eval_ (ρ: Env, e: Expr): ExplValue {
                [tv1, tv2]: [ExplValue, ExplValue] = [eval_(ρ, e.e1), eval_(ρ, e.e2)],
                [v1, v2]: [Value, Value] = [tv1.v, tv2.v]
          if ((v1 instanceof Num || v1 instanceof Str) && (v2 instanceof Num || v2 instanceof Str)) {
-               return explValue(Expl.binaryApp(tv1 as ExplValue<PrimValue>, e.opName, tv2 as ExplValue<PrimValue>)(kₜ), op.op(v1, v2)(kᵥ))
+            const k: MemoId = memoId(op.op, [v1, v2])
+            return explValue(Expl.binaryApp(tv1 as ExplValue<PrimValue>, e.opName, tv2 as ExplValue<PrimValue>)(kₜ), op.op(v1, v2)(k))
          } else {
             return error(`Applying "${e.opName}" to non-primitive value.`, v1, v2)
          }

diff --git a/src/Match.ts b/src/Match.ts
@@ -49,7 +49,8 @@ export abstract class Elim<K extends Cont = Cont> extends DataValue<"Elim"> {
 
 function apply_<K extends Cont> (σ: Elim<K>, tv: ExplValue, u̅: MatchPrefix): [Env, Match<K>] {
    if (VarElim.is(σ)) {
-      return [Env.singleton(σ.x, tv), match(u̅, σ.κ)]
+      const ρ: Env = σ.x.val === "_" ? emptyEnv() : Env.singleton(σ.x, tv)
+      return [ρ, match(u̅, σ.κ)]
    } else
    if (DataElim.is(σ)) {
       const v: Value = tv.v,

diff --git a/src/Parse.ts b/src/Parse.ts
@@ -18,7 +18,7 @@ const lexer = moo.compile({
    ident: {
       match: /[a-zA-Z_][0-9a-zA-Z_]*'*/, // greedy
       type: moo.keywords({
-        keyword: ["as", "match", "fun", "in", "let", "letrec", "primitive", "typematch"],
+        keyword: ["_", "as", "match", "fun", "in", "let", "letrec", "primitive", "typematch"],
       })
    },
    whitespace: {
@@ -339,6 +339,12 @@ const grammar: Grammar = {
     {"name": "pattern", "symbols": ["pair_pattern"], "postprocess": id},
     {"name": "pattern", "symbols": ["list_pattern"], "postprocess": id},
     {"name": "pattern", "symbols": ["constr_pattern"], "postprocess": id},
+    {"name": "variable_pattern$macrocall$2", "symbols": [{"literal":"_"}]},
+    {"name": "variable_pattern$macrocall$1$macrocall$2", "symbols": ["variable_pattern$macrocall$2"]},
+    {"name": "variable_pattern$macrocall$1$macrocall$1", "symbols": ["variable_pattern$macrocall$1$macrocall$2"], "postprocess": id},
+    {"name": "variable_pattern$macrocall$1$macrocall$1", "symbols": ["variable_pattern$macrocall$1$macrocall$2", "_"], "postprocess": ([x, ]) => x},
+    {"name": "variable_pattern$macrocall$1", "symbols": ["variable_pattern$macrocall$1$macrocall$1"]},
+    {"name": "variable_pattern", "symbols": ["variable_pattern$macrocall$1"], "postprocess": () => (κ: Cont) => varElim(str("_")(ν()), κ)(ν())},
     {"name": "variable_pattern", "symbols": ["var"], "postprocess": ([x]) => (κ: Cont) => varElim(x, κ)(ν())},
     {"name": "pair_pattern$macrocall$2", "symbols": [{"literal":"("}]},
     {"name": "pair_pattern$macrocall$1", "symbols": ["pair_pattern$macrocall$2"], "postprocess": id},

diff --git a/src/Value.ts b/src/Value.ts
@@ -64,7 +64,7 @@ function taggedId<Tag extends string> (k: Id, prop: Tag): TaggedId<Tag> {
    return make(TaggedId, k, prop) as TaggedId<Tag>
 }
 
-export function memoId (f: Function, v̅: IArguments): MemoId {
+export function memoId (f: Function, v̅: Iterable<any>): MemoId {
    const fʹ: FunctionId = functionId(f)
    let k: MemoId = fʹ
    for (let v of v̅) {

diff --git a/src/app/IDE.ts b/src/app/IDE.ts
@@ -4,4 +4,4 @@ import { openWithImports } from "../Module"
 import "../app/GraphicsRenderer"
 import { Editor } from "./Editor"
 
-new Editor(openWithImports("flatten"))
+new Editor(openWithImports("map"))
diff --git a/src/grammar.ne b/src/grammar.ne
@@ -6,7 +6,7 @@ const lexer = moo.compile({
    ident: {
       match: /[a-zA-Z_][0-9a-zA-Z_]*'*/, // greedy
       type: moo.keywords({
-        keyword: ["as", "match", "fun", "in", "let", "letrec", "primitive", "typematch"],
+        keyword: ["_", "as", "match", "fun", "in", "let", "letrec", "primitive", "typematch"],
       })
    },
    whitespace: {
@@ -62,6 +62,7 @@ rootExpr ->
 lexeme[X] ->
    $X {% id %} | 
    $X _ {% ([x, ]) => x %}
+
 keyword[X] -> lexeme[$X]
 
 _ -> (%whitespace | %singleLineComment):+
@@ -261,8 +262,10 @@ pattern ->
    list_pattern {% id %} |
    constr_pattern {% id %}
 
-variable_pattern -> 
-   var
+variable_pattern ->
+   keyword["_"]
+   {% () => (κ: Cont) => varElim(str("_")(ν()), κ)(ν()) %} |
+   var 
    {% ([x]) => (κ: Cont) => varElim(x, κ)(ν()) %}
 
 pair_pattern ->

diff --git a/test/Edit.ts b/test/Edit.ts
@@ -94,16 +94,16 @@ describe("edit", () => {
             }
 
             expect (here: ExplValueCursor) {
-               here = here.isChanged({ val: { before: 661, after: 39.125 } })
+               here = here.isNew()
                    .toTerminal()
                here.toBinaryArg2("/").isNew()
                here = here.toBinaryArg1("/").isNew()
                    .toTerminal()
                here.toBinaryArg1("+").isUnchanged()
-               here = here.toBinaryArg2("+").isChanged({ val: { before: 625, after: 42.25 } })
+               here = here.toBinaryArg2("+").isNew()
                    .toTerminal()
-               here.toBinaryArg1("*").isChanged({ val: { before: 25, after: 6.5 } })
-               here.toBinaryArg2("*").isChanged({ val: { before: 25, after: 6.5 } })
+               here.toBinaryArg1("*").isNew()
+               here.toBinaryArg2("*").isNew()
             }
          })(e)
       })

diff --git a/test/util/Core.ts b/test/util/Core.ts
@@ -68,13 +68,19 @@ export class BwdSlice {
 
 export class Edit {
    constructor (e: Expr, ρ: Env = emptyEnv()) {
+      if (flags.get(Flags.Visualise)) {
+         new Editor(e, ρ).render()
+      }
       if (flags.get(Flags.Edit)) {
          Eval.eval_(ρ, e)
          newRevision()
          this.setup(new ExprCursor(e))
          const tv: ExplValue =  Eval.eval_(ρ, e)
          this.expect(ExplValueCursor.descendant(null, tv))
       }
+      if (flags.get(Flags.Visualise)) {
+         new Editor(e, ρ).render()
+      }
    }
 
    setup (here: ExprCursor): void {