migrate from yaml-ast-parser -> yaml package

The module we were using the parse strings into yaml syntax trees was
not maintained, and had an awkward API. This meant that implementing
new features which dependend on YAML serialization and deserialization
were destined to be difficult. This includes implementing the print
function (#51)
which is on the hot path for the first iteration of an executable
program.

This uses the `npm:yaml` module (https://github.com/eemeli/yaml) as
the basis for converting strings into yaml AST. To do this, it uses a
"read" function which does a 1:1 mapping of yaml ast values to
PlatformScript values. the `read()` operation does not do anything
beyond this. So, for example, `read("$a-ref")` will be a `PSString`,
rather than a `PSRef`.

There is a `recognize()` operation that converts the "literal
platformscript" value into one that contains references, functions,
and templates. The "evaluation pipeline" now looks like this:

`pipe(read, recognize, eval)`

Mostly this change is limited to the `read`, however it does have some
small implications for the higher level apis because now references
are "recognized", not read directly, and so a reference value is not a
JavaScript string, but rather a `PSString`. The same applies for
function definitions. We now store the `head` of the function as a
reference to the `PSString` that gave rise to it. So, for example, in
the lambda:

```yaml
(x)=>: Hello %(x)
```

The `head` is the `PSString` `(x)=>`

> 💡When we have macros, we will probably insert that after `recognize`, but
> before `eval`. e.g.

`pipe(read, recognize, macroexpand, eval)`

Author: cowboyd

convert.ts

@@ -1,20 +1,4 @@
-import type {
-  YAMLMapping,
-  YAMLNode,
-  YAMLScalar,
-  YAMLSequence,
-} from "./deps.ts";
-import {
-  PSLiteral,
-  PSMapEntry,
-  PSMapKey,
-  PSString,
-  PSTemplate,
-  PSValue,
-} from "./types.ts";
-
-import { parseYAML } from "./deps.ts";
-import * as data from "./data.ts";
+import { PSMapEntry, PSMapKey, PSValue } from "./types.ts";
 
 /**
  * Convert a JavaScript value into a PlatformScript value
@@ -78,139 +62,3 @@ export function ps2js(value: PSValue): unknown {
       return value.value;
   }
 }
-
-/**
- * Convert source YAML into a PlatformScript Literal
- */
-export function yaml2ps(node: YAMLNode): PSLiteral<PSValue> {
-  if (node.kind === 0) { // String, Number, Boolean
-    let scalar = node as YAMLScalar;
-    if (
-      scalar.singleQuoted || scalar.doubleQuoted ||
-      typeof scalar.valueObject === "undefined"
-    ) {
-      let expressions = matchTemplate(scalar.value);
-      if (expressions.length > 0) {
-        return createLiteral({
-          type: "template",
-          value: scalar.value,
-          expressions,
-        }, node);
-      }
-      let match = matchReference(scalar.value);
-      if (match) {
-        return createLiteral({
-          type: "ref",
-          value: scalar.value,
-          key: match.key,
-          path: match.path,
-        }, node);
-      }
-      return createLiteral({
-        type: "string",
-        value: scalar.value,
-      }, node);
-    } else {
-      let value = scalar.valueObject;
-      let type = typeof scalar.valueObject;
-      if (!["number", "boolean"].includes(type)) {
-        throw new Error(`unknown scalar type: ${type}`);
-      }
-      return createLiteral({ type: type as "number" | "boolean", value }, node);
-    }
-  } else if (node.kind === 2) { // Map
-    let mappings: YAMLMapping[] = node.mappings ?? [];
-    let [first] = mappings;
-    if (!first) {
-      return { type: "map", value: new Map(), node };
-    } else {
-      let fnmatch = first.key.value.match(/^\(\s*(.*)\)\s*=>$/);
-      if (fnmatch) {
-        let param = fnmatch[1];
-        let body = yaml2ps(first.value);
-        return createLiteral({
-          type: "fn",
-          param: { name: param },
-          value: {
-            type: "platformscript",
-            body,
-          },
-        }, node);
-      } else {
-        return createLiteral({
-          type: "map",
-          value: new Map(mappings.map((m) => {
-            let value = yaml2ps(m.value);
-
-            // use method syntax
-            let mmatch = m.key.value.match(/^\s*(.+)\((.*)\)\s*$/);
-            if (mmatch) {
-              let [, key, param] = mmatch;
-              return [data.string(key), {
-                type: "fn",
-                param: { name: param },
-                value: {
-                  type: "platformscript",
-                  body: value,
-                },
-              } as PSValue];
-            } else {
-              return [yaml2ps(m.key) as PSString, value];
-            }
-          })),
-        }, node);
-      }
-    }
-  } else if (node.kind === 3) { // List
-    let list = node as YAMLSequence;
-    return createLiteral({
-      type: "list",
-      value: list.items.map(yaml2ps),
-    }, node);
-  } else {
-    console.dir({ node }, { depth: 10 });
-    throw new Error(`unknown YAMLNode of kind ${node.kind}`);
-  }
-}
-
-function matchTemplate(value: string) {
-  let valueIdx = 0;
-  let exprIdx = 1;
-  let regex = /%\(([\s\S]+?)\)/gmd;
-  let i = value.matchAll(regex);
-
-  let expressions: PSTemplate["expressions"] = [];
-
-  for (let next = i.next(); !next.done; next = i.next()) {
-    let match = next.value;
-    let expression = yaml2ps(parseYAML(match[exprIdx]));
-
-    expressions.push({
-      expression,
-
-      //@ts-expect-error RegExpMatchArray#indices not yet in the default TS lib
-      range: match.indices[valueIdx],
-    });
-  }
-  return expressions;
-}
-
-function matchReference(value: string) {
-  let pathIdx = 1;
-  let match = value.match(/^\$(\S+)$/);
-
-  if (match) {
-    let [key, ...path] = match[pathIdx].split(".");
-    return {
-      key,
-      path,
-    };
-  }
-}
-
-function createLiteral(value: PSValue, node: YAMLNode): PSLiteral {
-  return Object.defineProperty(value, "node", {
-    enumerable: false,
-    value: node,
-  }) as PSLiteral;
-}

data.ts

@@ -27,7 +27,7 @@ export function string(value: string): PSString {
 export function ref(key: string, path: string[]): PSRef {
   return {
     type: "ref",
-    value: `$${[key].concat(path).join(".")}`,
+    value: string(`$${[key].concat(path).join(".")}`),
     key,
     path,
   };

deps.ts

@@ -1,13 +1,7 @@
-export { load as parseYAML } from "https://esm.sh/yaml-ast-parser@0.0.43";
+export { default as yaml } from "https://esm.sh/yaml@2.2.1";
+export type { ParsedNode as YAMLParsedNode } from "https://esm.sh/yaml@2.2.1";
 export * from "https://raw.githubusercontent.com/cowboyd/instructional-effection/v0.0.0/mod.ts";
 export { resolve } from "https://deno.land/std@0.163.0/path/posix.ts";
-
-export type {
-  YAMLMapping,
-  YAMLNode,
-  YAMLScalar,
-  YAMLSequence,
-} from "https://esm.sh/yaml-ast-parser@0.0.43";
 export type {
   Operation,
   Task,

evaluate.ts

@@ -1,6 +1,5 @@
 import type {
   PSEnv,
-  PSFn,
   PSLiteral,
   PSMap,
   PSMapKey,
@@ -9,8 +8,8 @@ import type {
 } from "./types.ts";
 import type { Operation } from "./deps.ts";
 
-import { parseYAML } from "./deps.ts";
-import { yaml2ps } from "./convert.ts";
+import { read } from "./read.ts";
+import { recognize } from "./recognize.ts";
 import { concat, lookup, map, Maybe } from "./psmap.ts";
 import * as data from "./data.ts";
 
@@ -19,7 +18,7 @@ type Segment = {
   value: string;
 } | {
   type: "expr";
-  ref: PSLiteral;
+  ref: PSValue;
 };
 
 function* segments(t: PSTemplate): Generator<Segment> {
@@ -28,7 +27,7 @@ function* segments(t: PSTemplate): Generator<Segment> {
     let idx = 0;
     for (let expr of expressions) {
       let [start, end] = expr.range;
-      let substr = t.value.slice(idx, start);
+      let substr = t.value.value.slice(idx, start);
       yield {
         type: "const",
         value: substr,
@@ -39,16 +38,16 @@ function* segments(t: PSTemplate): Generator<Segment> {
       };
       idx = end;
     }
-    if (idx < t.value.length) {
+    if (idx < t.value.value.length) {
       yield {
         type: "const",
-        value: t.value.slice(idx),
+        value: t.value.value.slice(idx),
       };
     }
   } else {
     yield {
       type: "const",
-      value: t.value,
+      value: t.value.value,
     };
   }
 }
@@ -59,7 +58,7 @@ export function createYSEnv(parent = global): PSEnv {
       let scope = concat(parent, context);
       let env = createYSEnv(scope);
 
-      let value = yield* bind($value, scope, []);
+      let value = yield* bind(recognize($value), scope, []);
 
       if (value.type === "ref") {
         return value;
@@ -82,7 +81,7 @@ export function createYSEnv(parent = global): PSEnv {
             `${fn.value} is not a function. It is of type '${fn.type}'`,
           );
         }
-        return yield* env.call(fn, arg, rest);
+        return yield* env.call(fn, yield* env.eval(arg), rest);
       } else if (value.type === "map") {
         let entries: [PSMapKey, PSValue][] = [];
         for (let [k, v] of value.value.entries()) {
@@ -179,52 +178,8 @@ export const global: PSMap = {
   ]),
 };
 
-export function parse(source: string, filename = "script"): PSLiteral<PSValue> {
-  let yaml = parseYAML(source, { filename });
-  let [error] = yaml.errors;
-  if (!yaml) {
-    throw new SyntaxError(`empty string is not a YAML Document`);
-  } else if (error) {
-    throw error;
-  }
-  return yaml2ps(yaml);
-}
-
-export function strip(literal: PSValue): PSValue {
-  //@ts-expect-error stripping is safe because we're just dropping the node
-  let { node: _, ...value } = literal;
-  if (value.type === "map") {
-    let map = value.value;
-    return {
-      type: "map",
-      value: new Map(
-        [...map.entries()].map(([k, v]) => [strip(k) as PSMapKey, strip(v)]),
-      ),
-    };
-  } else if (value.type === "list") {
-    let list = value.value;
-    return {
-      type: "list",
-      value: list.map((val) => strip(val as PSLiteral<PSValue>)),
-    };
-  } else if (value.type === "fn" && value.value.type === "platformscript") {
-    let { body } = value.value;
-    return {
-      ...value,
-      value: {
-        type: "platformscript",
-        body: strip(body),
-      },
-    };
-  } else if (value.type === "fncall") {
-    return {
-      ...value,
-      value: strip(value.value) as PSFn,
-      arg: strip(value.arg),
-    };
-  } else {
-    return value;
-  }
+export function parse(source: string, _filename = "script"): PSValue {
+  return read(source);
 }
 
 // this is kinda cheesy. We should beef up this check.
@@ -321,44 +276,21 @@ function* bind(
     }
     return data.list(result);
   } else if (value.type === "map") {
-    let entries = [...value.value.entries()];
-    let [first, ...rest] = entries;
-
-    if (!first) {
-      //TODO: what is this for?
-      return { type: "boolean", value: false };
-    } else {
-      let [key, value] = first;
-      if (key.type === "ref") {
-        let fn = mask.includes(key.key) ? key : yield* bind(key, scope, mask);
-        if (fn.type !== "fn" && fn.type !== "ref") {
-          throw new Error(
-            `'${key.value}' is not a function, it is a ${fn.type}`,
-          );
-        }
-        return {
-          type: "fncall",
-          value: fn,
-          arg: yield* bind(value, scope, mask),
-          rest: { type: "map", value: new Map(rest) },
-        };
-      } else {
-        let $entries = [] as [PSMapKey, PSValue][];
-        for (let [k, v] of entries) {
-          $entries.push([k, yield* bind(v, scope, mask)]);
-        }
-        return {
-          type: "map",
-          value: new Map($entries),
-        };
-      }
+    let $entries = [] as [PSMapKey, PSValue][];
+    for (let [k, v] of value.value.entries()) {
+      $entries.push([k, yield* bind(v, scope, mask)]);
     }
+    return {
+      type: "map",
+      value: new Map($entries),
+    };
   } else if (value.type === "fn" && value.value.type === "platformscript") {
     let { param, value: { body } } = value;
     return {
       ...value,
       value: {
         type: "platformscript",
+        head: value.value.head,
         body: yield* bind(body, scope, mask.concat(param.name)),
       },
     };

mod.ts

@@ -1,5 +1,6 @@
 export * from "./types.ts";
 export * from "./convert.ts";
+export * from "./read.ts";
 export * from "./evaluate.ts";
 export * from "./load.ts";
 export * from "./platformscript.ts";

psmap.ts

@@ -37,10 +37,13 @@ export type Maybe<T> =
     value: void;
   };
 
-export function lookup(key: string, map: PSMap): Maybe<PSValue> {
+export function lookup(
+  key: string | number | boolean,
+  map: PSMap,
+): Maybe<PSValue> {
   for (let entry of map.value.entries()) {
     let [k, value] = entry;
-    if (k.value.toString() === key) {
+    if (k.value === key) {
       return { type: "just", value };
     }
   }