feat(core): nearley parser

.vscode/settings.json

@@ -13,6 +13,8 @@
     "hacky",
     "idrc",
     "iife",
+    "lparan",
+    "nearley",
     "outdir",
     "pcss",
     "peaceiris",
@@ -22,6 +24,7 @@
     "prebuild",
     "purescript",
     "purs",
+    "rparan",
     "spago",
     "thomashoneyman"
   ],

config/webpack.common.js

@@ -43,6 +43,14 @@ module.exports = {
         options: {
           loader: "ts"
         }
+      },
+      {
+        test: /\.ne$/,
+        use: [
+          {
+            loader: "nearley-loader"
+          }
+        ]
       }
     ]
   },

package.json

@@ -12,6 +12,8 @@
   "devDependencies": {
     "@semantic-release/changelog": "^5.0.1",
     "@semantic-release/git": "^9.0.0",
+    "@types/moo": "^0.5.3",
+    "@types/nearley": "^2.11.1",
     "autoprefixer": "^10.0.1",
     "clean-webpack-plugin": "^3.0.0",
     "compression-webpack-plugin": "^6.0.5",
@@ -22,6 +24,8 @@
     "esbuild-loader": "^2.4.0",
     "html-webpack-plugin": "^4.5.0",
     "mini-css-extract-plugin": "^1.2.1",
+    "nearley": "^2.19.7",
+    "nearley-loader": "^2.0.0",
     "optimize-css-assets-webpack-plugin": "^5.0.4",
     "postcss": "^8.1.1",
     "postcss-font-magician": "^2.3.1",
@@ -42,6 +46,7 @@
     "@thi.ng/hiccup-canvas": "^1.1.10",
     "@thi.ng/vectors": "^4.7.0",
     "fibers": "^5.0.0",
+    "moo": "^0.5.1",
     "preact": "^10.5.5",
     "sass": "^1.29.0"
   }

src/ast.ts

@@ -0,0 +1,20 @@
+// TODO: make this include position data.
+type TermInput<T> = {
+  application: (left: T, right: T) => T
+  abstraction: (name: string, body: T) => T
+  variable: (name: string) => T
+}
+
+type Term<T> = (input: TermInput<T>) => T
+
+export const call = <T>(left: Term<T>, right: Term<T>): Term<T> => (config) =>
+  config.application(left(config), right(config))
+
+export const abstract = <T>(name: string, body: Term<T>): Term<T> => (config) =>
+  config.abstraction(name, body(config))
+
+export const variable = <T>(name: string): Term<T> => (config) =>
+  config.variable(name)
+
+export const abstractMany = <T>(names: string[], body: Term<T>): Term<T> =>
+  names.reduceRight((previous, name) => abstract(name, previous), body)

src/entry.js

@@ -1,6 +1,8 @@
 console.log("Loaded root")
 console.time("Loaded purescript")
 
+import "./parser.ts"
+
 import("purescript/Main").then(({ main }) => {
   console.timeEnd("Loaded purescript")
 

src/lexer.ts

@@ -0,0 +1,58 @@
+import moo from "moo"
+
+export interface Position {
+  line: number
+  col: number
+}
+
+export interface Token {
+  start: Position
+  end: Position
+  type?: string
+  value: string
+}
+
+export const lexer = moo.compile({
+  ws: /[ \t]+/,
+  nl: { match: "\n", lineBreaks: true },
+  lambdaChar: ["λ", "\\"],
+  arrowChar: ["->", "."],
+  lparan: "(",
+  rparan: ")",
+  identifier: {
+    match: /[a-z_][a-z_0-9]*/
+  }
+})
+
+export function tokenStart(token: moo.Token): Position {
+  return {
+    line: token.line,
+    col: token.col - 1
+  }
+}
+
+export function tokenEnd(token: moo.Token): Position {
+  const lastNewLine = token.text.lastIndexOf("\n")
+
+  if (lastNewLine !== -1) {
+    throw new Error("Unsupported case: token with line breaks")
+  }
+
+  return {
+    line: token.line,
+    col: token.col + token.text.length - 1
+  }
+}
+
+export function convertToken(token: moo.Token): Token {
+  return {
+    type: token.type,
+    value: token.value,
+    start: tokenStart(token),
+    end: tokenEnd(token)
+  }
+}
+
+export function convertTokenId(data: moo.Token[]): Token {
+  return convertToken(data[0])
+}

src/parser.ts

@@ -0,0 +1,14 @@
+// @ts-ignore
+import syntax from "./syntax.ne"
+import { Parser, Grammar } from "nearley"
+
+const parser = new Parser(Grammar.fromCompiled(syntax))
+
+parser.feed("\\f a b. f b a \\l. l")
+const result = parser.results[0]({
+  variable: (d) => d,
+  abstraction: (name, body) => ({ name, body }),
+  application: (left, right) => ({ left, right })
+})
+
+console.log(result)

src/syntax.ne

@@ -0,0 +1,42 @@
+@{%
+const { lexer, tokenStart, convertTokenId } = require("./lexer.ts")
+const { call, abstract, variable, abstractMany } = require("./ast.ts")
+%}
+
+@lexer lexer
+
+expression 
+    -> application {% id %}
+    |  abstraction {% id %}
+
+application 
+    -> no_lambda_application  {% id %}
+    | no_lambda_application __ abstraction
+        {% ([left, _, right]) => call(left, right) %}
+
+no_lambda_application 
+    -> atom {% id %}
+    |  no_lambda_application __ atom
+        {% ([left, _, right]) => call(left, right) %}
+
+
+atom
+    -> "(" _ expression _ ")" {% d => d[2] %}
+    |   variable {% id %} 
+
+variable 
+    -> identifier 
+        {% ([d]) => variable(d.value) %}
+
+abstraction
+    -> lambdaChar lambdaArgs _ arrowChar _ expression
+        {% d => abstractMany(d[1].map(a => a.value), d[5]) %}
+
+lambdaArgs -> (_ identifier _ {% d => d[1] %}):+ {% id %}
+
+# Lexing
+arrowChar -> %arrowChar {% convertTokenId %}
+lambdaChar -> %lambdaChar {% convertTokenId %}
+identifier -> %identifier {% convertTokenId %}
+__ -> %ws:+
+_ -> %ws:*