0.2.4

.github/workflows/deno.yml

@@ -11,6 +11,8 @@ name: Deno
 on:
   push:
     branches-ignore: []
+    tags:
+      - '**'
   pull_request:
     branches-ignore: []
 

deno.json

@@ -1,11 +1,5 @@
 {
     "tasks": {
         "build_npm": "deno run -A scripts/build_npm.ts"
-    },
-    "imports": {
-        "ts-pattern": "npm:ts-pattern@5.0.5",
-        "iteruyo": "https://deno.land/x/iteruyo@v0.3.0/mod.ts",
-        "std/assert": "https://deno.land/std@0.201.0/assert/mod.ts",
-        "util/": "./src/util/"
     }
 }

deps.ts

@@ -0,0 +1,9 @@
+export {
+    match,
+    P,
+} from "npm:ts-pattern@5.0.5"
+export { $ as Iter } from "https://deno.land/x/iteruyo@v0.3.0/mod.ts"
+export {
+    assertEquals,
+    assertNotEquals,
+} from "https://deno.land/std@0.201.0/assert/mod.ts"

mod.ts

@@ -0,0 +1 @@
+export * from "./src/mod.ts"

src/Expr.ts

@@ -1,11 +1,16 @@
 export type Expr =
     | {ref: string}
-    | {literal: string}
-    | {def: [string, Expr]}
-    | {join: [Expr, Expr]}
+    | {literal: string | number}
+    | {def: [Expr, Expr]}
     | {or: [Expr, Expr]}
     | {and: [Expr, Expr]}
     | {symbol: string}
     | {call: [Expr, Expr]}
+    | {arrow: [Expr, Expr]}
+    | {capture: [string, Expr]}
+    | {guard: Expr}
+    | {js_arrow: (x: Expr) => Expr}
+    | {f: string, args: [Expr, Expr]}
 
-export const any = {symbol: "any"}
+export const any = {symbol: "any"}
+export const non = {symbol: "non"}

src/expand.ts

@@ -1,10 +1,10 @@
 import { Expr } from "./Expr.ts"
-import { call, join } from "./func/mod.ts"
+import { call, expandable } from "./func/mod.ts"
 
-import { match, P } from "ts-pattern"
-import { $ as Iter } from "iteruyo"
-import { $a, $b } from "util/select.ts"
-export * from "iteruyo"
+import { match, P } from "../deps.ts"
+import { Iter } from "../deps.ts"
+import { $, $a, $b, f } from "./util/mod.ts"
+export * from "../deps.ts"
 
 class LazyArray<T> {
     memory: T[] = []
@@ -46,11 +46,11 @@ export const expand = (query: Expr) => function*(expr: Expr): Generator<Expr, vo
     yield* match(call(query, expr))
     .with({or: [$a, $b]}, function*({a, b}) {
         yield* match([a, b])
-        .with([{literal: P.string}, P.any], function*() {
+        .with([{literal: P.any}, P.any], function*() {
             yield a
             yield* expand(b)(expr)
         })
-        .with([P.any, {literal: P.string}], function*() {
+        .with([P.any, {literal: P.any}], function*() {
             yield b
             yield* expand(a)(expr)
         })
@@ -61,11 +61,11 @@ export const expand = (query: Expr) => function*(expr: Expr): Generator<Expr, vo
             )
         })
     })
-    .with({join: [$a, $b]}, ({a, b}) => {
+    .with({f: $("f"), args: [$a, $b]}, ({f, a, b}) => {
         const aStash = new LazyArray(expand(a)(expr))
         const bStash = new LazyArray(expand(b)(expr))
         return Iter(fill(x => !aStash.at(x), y => !bStash.at(y)))
-            .map(([x, y]) => join(aStash.at(x), bStash.at(y)))
+            .map(([x, y]) => expandable[f](aStash.at(x), bStash.at(y)))
     })
     .otherwise(x => [x])
 }

src/func/and.ts

@@ -1,10 +1,40 @@
-import { Expr, any } from "../Expr.ts"
+import { Expr, any, non } from "../Expr.ts"
 
-import { match } from "ts-pattern"
-import { $_ } from "util/select.ts"
+import { match, P } from "../../deps.ts"
+import { $, $a, $b, commu } from "../util/mod.ts"
+
+import { call } from "./call.ts"
+import { or } from "./or.ts"
 
 export const and = (a: Expr, b: Expr): Expr =>
     match([a, b])
-    .with([$_, any], x => x)
-    .with([any, $_], x => x)
+    .with(
+        commu([
+            {or: [$("a1"), $("a2")] as const},
+            $b,
+        ]),
+        ({a1, a2, b}) => {
+            return or(
+                and(a1!, b!),
+                and(a2!, b!),
+            )
+        }
+    )
+    .with(
+        [{literal: $a}, {literal: $b}],
+        ({a, b}) => {
+            return a === b
+                ? {literal: a}
+                : non
+        }
+    )
+    .with(
+        commu([
+            {guard: $a},
+            $b,
+        ]),
+        ({a, b}) => call(a!, b!)
+    )
+    .with(commu([P.any, non]), () => non)
+    .with(commu([$a, any]), ({a}) => a!)
     .otherwise(_ => ({and: [a, b]}))

src/func/basic.ts

@@ -0,0 +1,29 @@
+import { Expr } from "../Expr.ts";
+
+export const literal =
+    (value: string | number) =>
+    ({literal: value})
+
+export const ref =
+    (name: string) =>
+    ({ref: name})
+
+export const def =
+    (name: Expr, expr: Expr): Expr =>
+    ({def: [name, expr]})
+
+export const arrow =
+    (from: Expr, to: Expr): Expr =>
+    ({arrow: [from, to]})
+
+export const capture =
+    (name: string, type: Expr): Expr =>
+    ({capture: [name, type]})
+
+export const guard =
+    (f: Expr) =>
+    ({guard: f})
+
+export const js_arrow =
+    (f: (x: Expr) => Expr) =>
+    ({js_arrow: f})

src/func/call.ts

@@ -1,27 +1,83 @@
-import { Expr, any } from "../Expr.ts"
+import { Expr, any, non } from "../Expr.ts"
 import { and } from "./and.ts"
+import { or } from "./or.ts"
 import { join } from "./join.ts"
+import {
+    add,
+    sub,
+    mul,
+    div,
+} from "./math.ts"
 
-import { match, P } from "ts-pattern"
-import { $_, $a, $b } from "util/select.ts"
+import { match, P } from "../../deps.ts"
+import { $, $_, $a, $b, commu } from "../util/mod.ts"
 
 export const call = (query: Expr, expr: Expr): Expr => {
-    return match(query)
-    .with({ref: $_}, name =>
-        match(expr)
-        .with({def: [name, $_]}, value => {
-            return value
-        })
-        .with({and: [$a, $b]}, ({a, b}) => {
-            return and(
+    return match([query, expr])
+    .with([P.any, non], () => any)
+    .with(
+        [$("q"), {or: [$a, $b]}],
+        ({a, b, q}) => or(call(q, a), call(q, b))
+    )
+    .with(
+        [{ref: P.any}, {def: [{ref: P.any}, $_]}],
+        ([{ref}, {def: [{ref: name}, _val]}]) => ref == name,
+        val => val
+    )
+    .with(
+        [{ref: $("name")}, {and: [$a, $b]}],
+        ({name, a, b}) =>
+            and(
                 call({ref: name}, a),
                 call({ref: name}, b),
             )
-        })
+    )
+    .with([{ref: P.any}, P.any], () => any)
+    .with(
+        [{arrow: [{literal: P.any}, $_]}, {literal: P.any}],
+        ([{arrow: [{literal: a1}, _]}, {literal: a2}]) => a1 == a2,
+        val => val
+    )
+    .with(
+        [{arrow: [{capture: $a}, $b]}, P.any],
+        ({a: [name, type], b}) => // TODO: Type Checking
+        match(expr)
+        .with($_, () => call(b, {def: [
+            {ref: name},
+            and(expr, type),
+        ]}))
         .otherwise(() => any)
     )
-    .with({join: [$a, $b]}, ({a, b}) => {
-        return join(call(a, expr), call(b, expr))
-    })
-    .otherwise(q => q)
+    .with([{arrow: P.any}, P.any], () => any)
+    .with([{call: [$a, $b]}, P.any], ({a, b}) => call(
+        call(a, expr),
+        call(b, expr),
+    ))
+    .with([{and: [$a, $b]}, P.any], ({a, b}) => and(
+        call(a, expr),
+        call(b, expr),
+    ))
+    .with(
+        [{f: P.any, args: commu([non, P.any])}, P.any],
+        () => any
+    )
+    .with(
+        [{f: $("name"), args: $("args")}, P.any],
+        ({name, args}) => {
+            return {
+                join,
+                add,
+                sub,
+                mul,
+                div,
+            }[name as "join"](
+                ...args.map(arg => call(arg, expr)) as typeof args
+            )
+        }
+    )
+    .with(
+        [{js_arrow: $("f")}, $a],
+        ({f, a}) => f(a)
+    )
+    .otherwise(_ => query)
 }

src/func/join.ts

@@ -1,12 +1,12 @@
 import { Expr } from "../Expr.ts"
 
-import { match } from "ts-pattern"
-import { $a, $b } from "util/select.ts"
+import { match } from "../../deps.ts"
+import { f, str$a, str$b } from "../util/mod.ts"
 
 export const join = (a: Expr, b: Expr): Expr =>
     match([a, b])
     .with(
-        [{literal: $a}, {literal: $b}],
+        [{literal: str$a}, {literal: str$b}],
         ({a, b}) => ({literal: a + b}),
     )
-    .otherwise(() => ({join: [a, b]}))
+    .otherwise(() => f({join: [a, b]}))

src/func/math.ts

@@ -0,0 +1,23 @@
+import { Expr, non, any } from "../Expr.ts"
+
+import { P, match } from "../../deps.ts"
+import { num$a, num$b, commu } from "../util/mod.ts"
+
+const math =
+    (name: string, func: (a: number, b: number) => number) =>
+    (a: Expr, b: Expr): Expr =>
+    match([a, b])
+    .with(
+        commu([non, P.any]),
+        () => any
+    )
+    .with(
+        [{literal: num$a}, {literal: num$b}],
+        ({a, b}) => ({literal: func(a, b)})
+    )
+    .otherwise(() => ({f: name, args: [a, b]}))
+
+export const add = math("add", (a, b) => a + b)
+export const sub = math("sub", (a, b) => a - b)
+export const mul = math("mul", (a, b) => a * b)
+export const div = math("div", (a, b) => a / b)

src/func/mod.ts

@@ -1,3 +1,13 @@
 export * from "./and.ts"
 export * from "./call.ts"
-export * from "./join.ts"
+export * from "./join.ts"
+export * from "./basic.ts"
+export * from "./math.ts"
+export * from "./or.ts"
+
+import { join, or, add, sub, mul, div } from "./mod.ts"
+
+import { Expr } from "../Expr.ts"
+
+export const expandable: Record<string, (a: Expr, b: Expr) => Expr> = 
+    { join, or, add, sub, mul, div }

src/func/or.ts

@@ -0,0 +1,10 @@
+import { Expr, any, non } from "../Expr.ts"
+
+import { match, P } from "../../deps.ts"
+import { $a, commu } from "../util/mod.ts"
+
+export const or = (a: Expr, b: Expr): Expr =>
+    match([a, b])
+    .with(commu([$a, non]), ({a}) => a!)
+    .with(commu([P.any, any]), () => any)
+    .otherwise(_ => ({or: [a, b]}))

src/mod.ts

@@ -1,4 +1,7 @@
 export * from "./func/mod.ts"
+export * from "./std/mod.ts"
 export * from "./expand.ts"
 export * from "./Expr.ts"
-export * from "./run.ts"
+export * from "./run.ts"
+
+export * from "./util/f.ts"

src/run.ts

@@ -1,8 +1,8 @@
 import { Expr } from "./Expr.ts"
 import { and, call } from "./func/mod.ts"
 
-import { match, P } from "ts-pattern"
-import { $, $a, $b } from "util/select.ts"
+import { match, P } from "../deps.ts"
+import { $, $a, $b } from "./util/mod.ts"
 
 export const run = (expr: Expr): Expr => {
     return match(expr)

src/std/mod.ts

@@ -0,0 +1,22 @@
+import { guard, js_arrow } from "../func/basic.ts"
+import { Expr, non } from "../Expr.ts"
+
+const predicate =
+    (check: (x: Expr) => boolean) =>
+    guard(
+        js_arrow(
+            x => check(x) ? x : non
+        )
+    )
+
+export const num = 
+    predicate(x =>
+        "literal" in x &&
+        typeof x?.literal == "number"
+    )
+
+export const str = 
+    predicate(x =>
+        "literal" in x &&
+        typeof x?.literal == "string"
+    )