remove sexp/

Author: xieyuheng

TODO.md

@@ -1,2 +1,2 @@
-remove `sexp/`
+fix `examples/list.scm`
 review diary

examples/list.scm

@@ -1,39 +1,39 @@
-(define nil
-  (lambda (nil-case ::-case)
-    nil-case))
-
-(define (:: head tail)
-  (lambda (nil-case ::-case)
-    (::-case head tail
-      (tail nil-case ::-case))))
-
-(define (rec-List target nil-case ::-case)
-  (target nil-case ::-case))
-
-(import zero add1 "./nat-church.scm")
-
-(define (length l)
-  (rec-List l
-    zero
-    (lambda (head target almost)
-      (add1 almost))))
-
-(import true "./boolean.scm")
-
-(assert-equal (length nil) zero)
-(assert-equal (length (:: true nil)) (add1 zero))
-(assert-equal (length (:: true (:: true nil))) (add1 (add1 zero)))
-
-(define (append left right)
-  (rec-List left
-    right
-    (lambda (head target almost)
-      (:: head almost))))
-
-(assert-equal (append nil nil) nil)
-(assert-equal (append nil (:: true nil)) (:: true nil))
-(assert-equal (append (:: true nil) nil) (:: true nil))
-(assert-equal (append (:: true nil) (:: true nil)) (:: true (:: true nil)))
-(assert-equal (append (:: true (:: true nil))
-                      (:: true (:: true nil)))
-              (:: true (:: true (:: true (:: true nil)))))
+;; (define nil
+;;   (lambda (nil-case ::-case)
+;;     nil-case))
+
+;; (define (:: head tail)
+;;   (lambda (nil-case ::-case)
+;;     (::-case head tail
+;;       (tail nil-case ::-case))))
+
+;; (define (rec-List target nil-case ::-case)
+;;   (target nil-case ::-case))
+
+;; (import zero add1 "./nat-church.scm")
+
+;; (define (length l)
+;;   (rec-List l
+;;     zero
+;;     (lambda (head target almost)
+;;       (add1 almost))))
+
+;; (import true "./boolean.scm")
+
+;; (assert-equal (length nil) zero)
+;; (assert-equal (length (:: true nil)) (add1 zero))
+;; (assert-equal (length (:: true (:: true nil))) (add1 (add1 zero)))
+
+;; (define (append left right)
+;;   (rec-List left
+;;     right
+;;     (lambda (head target almost)
+;;       (:: head almost))))
+
+;; (assert-equal (append nil nil) nil)
+;; (assert-equal (append nil (:: true nil)) (:: true nil))
+;; (assert-equal (append (:: true nil) nil) (:: true nil))
+;; (assert-equal (append (:: true nil) (:: true nil)) (:: true (:: true nil)))
+;; (assert-equal (append (:: true (:: true nil))
+;;                       (:: true (:: true nil)))
+;;               (:: true (:: true (:: true (:: true nil)))))

examples/tests/let.scm

@@ -1,2 +1,2 @@
-(let ([id (lambda (x) x)])
+(let ((id (lambda (x) x)))
   (id id))

package-lock.json

@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "@xieyuheng/commander.js": "^0.1.3",
-    "@xieyuheng/x-data.js": "^0.1.1",
+    "@xieyuheng/x-data.js": "^0.1.4",
     "dedent": "^1.6.0",
     "regexp-match-indices": "^1.0.2"
   },

package.json

@@ -1,5 +1,5 @@
+import { ParsingError } from "@xieyuheng/x-data.js"
 import fs from "node:fs"
-import { ParsingError } from "../../sexp/index.ts"
 import { createMod, modResolve, type Mod } from "../mod/index.ts"
 import { parseStmts } from "../syntax/index.ts"
 

src/lang/run/load.ts

@@ -1,59 +1,44 @@
-import {
-  cons,
-  match,
-  matchList,
-  matchSymbol,
-  v,
-  type Sexp,
-} from "../../sexp/index.ts"
+import * as X from "@xieyuheng/x-data.js"
 import * as Exps from "../exp/index.ts"
 import { type Exp } from "../exp/index.ts"
 import {
   substitutionFromBindings,
   type Binding,
 } from "../substitution/index.ts"
 
-export function matchExp(sexp: Sexp): Exp {
-  return match<Exp>(sexp, [
-    [
-      ["lambda", v("names"), v("exp")],
-      ({ names, exp }) =>
-        matchList(names, matchSymbol).reduceRight(
-          (fn, name) => Exps.Fn(name, fn),
-          matchExp(exp),
-        ),
-    ],
+const expMatcher: X.Matcher<Exp> = X.matcherChoice<Exp>([
+  X.matcher("`(lambda ,names ,exp)", ({ names, exp }) =>
+    X.dataToArray(names)
+      .map(X.dataToString)
+      .reduceRight((fn, name) => Exps.Fn(name, fn), matchExp(exp)),
+  ),
+
+  X.matcher("`(let ,bindings ,body)", ({ bindings, body }) =>
+    Exps.Let(
+      substitutionFromBindings(X.dataToArray(bindings).map(matchBinding)),
+      matchExp(body),
+    ),
+  ),
 
-    [
-      ["let", v("bindings"), v("body")],
-      ({ bindings, body }) =>
-        Exps.Let(
-          substitutionFromBindings(matchList(bindings, matchBinding)),
-          matchExp(body),
-        ),
-    ],
+  X.matcher("(cons target args)", ({ target, args }) =>
+    X.dataToArray(args)
+      .map(matchExp)
+      .reduce((result, arg) => Exps.Ap(result, arg), matchExp(target)),
+  ),
 
-    [
-      cons(v("target"), v("args")),
-      ({ target, args }) =>
-        matchList(args, matchExp).reduce(
-          (result, arg) => Exps.Ap(result, arg),
-          matchExp(target),
-        ),
-    ],
+  X.matcher("name", ({ name }) => Exps.Var(X.dataToString(name))),
+])
 
-    [v("name"), ({ name }) => Exps.Var(matchSymbol(name))],
-  ])
+export function matchExp(data: X.Data): Exp {
+  return X.match(expMatcher, data)
 }
 
-export function matchBinding(sexp: Sexp): Binding {
-  return match<Binding>(sexp, [
-    [
-      [v("name"), v("exp")],
-      ({ name, exp }) => ({
-        name: matchSymbol(name),
-        exp: matchExp(exp),
-      }),
-    ],
-  ])
+export function matchBinding(data: X.Data): Binding {
+  return X.match(
+    X.matcher("`(,name ,exp)", ({ name, exp }) => ({
+      name: X.dataToString(name),
+      exp: matchExp(exp),
+    })),
+    data,
+  )
 }

src/lang/syntax/matchExp.ts

@@ -1,71 +1,59 @@
-import {
-  cons,
-  listToArray,
-  match,
-  matchList,
-  matchString,
-  matchSymbol,
-  v,
-  type Sexp,
-} from "../../sexp/index.ts"
+import * as X from "@xieyuheng/x-data.js"
 import * as Exps from "../exp/index.ts"
 import * as Stmts from "../stmt/index.ts"
 import { type Stmt } from "../stmt/index.ts"
 import { matchExp } from "./matchExp.ts"
 
-export function matchStmt(sexp: Sexp): Stmt {
-  return match<Stmt>(sexp, [
-    [
-      ["define", cons(v("name"), v("args")), v("exp")],
-      ({ name, args, exp }) =>
-        Stmts.Define(
-          matchSymbol(name),
-          matchList(args, matchSymbol).reduceRight(
-            (fn, name) => Exps.Fn(name, fn),
-            matchExp(exp),
-          ),
-        ),
-    ],
-
-    [
-      ["define", v("name"), v("exp")],
-      ({ name, exp }) => Stmts.Define(matchSymbol(name), matchExp(exp)),
-    ],
-
-    [
-      cons("import", v("body")),
-      ({ body }) => {
-        const sexps = listToArray(body)
-        const url = sexps[sexps.length - 1]
-        const entries = sexps.slice(0, sexps.length - 1)
-        return Stmts.Import(matchString(url), entries.map(matchImportEntry))
-      },
-    ],
-
-    [
-      cons("assert-equal", v("exps")),
-      ({ exps }) => Stmts.AssertEqual(matchList(exps, matchExp)),
-    ],
-
-    [
-      cons("assert-not-equal", v("exps")),
-      ({ exps }) => Stmts.AssertNotEqual(matchList(exps, matchExp)),
-    ],
-
-    [v("exp"), ({ exp }) => Stmts.Compute(matchExp(exp))],
-  ])
+const stmtMatcher: X.Matcher<Stmt> = X.matcherChoice<Stmt>([
+  X.matcher("`(define ,(cons name args) ,exp)", ({ name, args, exp }) =>
+    Stmts.Define(
+      X.dataToString(name),
+      X.dataToArray(args)
+        .map(X.dataToString)
+        .reduceRight((fn, name) => Exps.Fn(name, fn), matchExp(exp)),
+    ),
+  ),
+
+  X.matcher("`(define ,name ,exp)", ({ name, exp }) =>
+    Stmts.Define(X.dataToString(name), matchExp(exp)),
+  ),
+
+  X.matcher("(cons 'import body)", ({ body }) => {
+    const array = X.dataToArray(body)
+    const url = array[array.length - 1]
+    const entries = array.slice(0, array.length - 1)
+    return Stmts.Import(X.dataToString(url), entries.map(matchImportEntry))
+  }),
+
+  X.matcher("(cons 'import exps)", ({ exps }) =>
+    Stmts.AssertEqual(X.dataToArray(exps).map(matchExp)),
+  ),
+
+  X.matcher("(cons 'assert-equal exps)", ({ exps }) =>
+    Stmts.AssertEqual(X.dataToArray(exps).map(matchExp)),
+  ),
+
+  X.matcher("(cons 'assert-not-equal exps)", ({ exps }) =>
+    Stmts.AssertNotEqual(X.dataToArray(exps).map(matchExp)),
+  ),
+
+  X.matcher("exp", ({ exp }) => Stmts.Compute(matchExp(exp))),
+])
+
+export function matchStmt(data: X.Data): Stmt {
+  return X.match(stmtMatcher, data)
 }
 
-function matchImportEntry(sexp: Sexp): Stmts.ImportEntry {
-  return match<Stmts.ImportEntry>(sexp, [
-    [
-      ["rename", v("name"), v("rename")],
-      ({ name, rename }) => ({
-        name: matchSymbol(name),
-        rename: matchSymbol(rename),
-      }),
-    ],
-
-    [v("name"), ({ name }) => ({ name: matchSymbol(name) })],
-  ])
+function matchImportEntry(data: X.Data): Stmts.ImportEntry {
+  return X.match(
+    X.matcherChoice([
+      X.matcher("`(rename ,name ,rename)", ({ name, rename }) => ({
+        name: X.dataToString(name),
+        rename: X.dataToString(rename),
+      })),
+
+      X.matcher("name", ({ name }) => ({ name: X.dataToString(name) })),
+    ]),
+    data,
+  )
 }

src/lang/syntax/matchStmt.ts

@@ -1,25 +1,7 @@
-import { Parser as SexpParser } from "../../sexp/index.ts"
+import { parseDataArray } from "@xieyuheng/x-data.js"
 import { type Stmt } from "../stmt/index.ts"
 import { matchStmt } from "./matchStmt.ts"
 
-class Parser extends SexpParser {
-  constructor() {
-    super({
-      quotes: [
-        { mark: "'", symbol: "quote" },
-        { mark: ",", symbol: "unquote" },
-        { mark: "`", symbol: "quasiquote" },
-      ],
-      brackets: [
-        { start: "(", end: ")" },
-        { start: "[", end: "]" },
-      ],
-      comments: [";"],
-    })
-  }
-}
-
 export function parseStmts(text: string): Array<Stmt> {
-  const parser = new Parser()
-  return parser.parseSexps(text).map(matchStmt)
+  return parseDataArray(text).map(matchStmt)
 }