shapedef 1.0.19 → 1.0.21

package/src/turing/turing.ts

@@ -0,0 +1,160 @@
+import {
+  OutputOfShape,
+  Shape,
+  ShapeBool,
+  ShapeDate,
+  ShapeNil,
+  ShapeNumber,
+  ShapeRef,
+  shapes,
+  ShapeStr,
+  ShapeUnknown,
+} from "../shape";
+import { TuringOp } from "./op";
+
+export type TuringPhantom = {
+  out: any;
+};
+
+export type LooseTuring = {
+  type: string;
+  __phantom: TuringPhantom;
+};
+
+export type OutputOfTuring<T> =
+  [T] extends [LooseTuring] ? T["__phantom"]["out"] : never;
+
+export interface TuringBase<Type extends string> {
+  type: Type;
+  __phantom: TuringPhantom;
+}
+
+export interface TuringWithOutput<
+  Type extends string,
+  Out,
+> extends TuringBase<Type> {
+  __phantom: {
+    out: Out;
+  };
+}
+
+export interface TuringWithShape<
+  Type extends string,
+  S extends Shape,
+> extends TuringWithOutput<Type, OutputOfShape<S>> {
+  shape: S;
+}
+
+export interface TuringNumber extends TuringWithShape<"number", ShapeNumber> {
+  value: number;
+}
+export interface TuringBool extends TuringWithShape<"bool", ShapeBool> {
+  value: boolean;
+}
+export interface TuringStr extends TuringWithShape<"str", ShapeStr> {
+  value: string;
+}
+export interface TuringDate extends TuringWithShape<"date", ShapeDate> {
+  value: Date;
+}
+export interface TuringNil extends TuringWithShape<"nil", ShapeNil> {
+  value: null;
+}
+export interface TuringRef<
+  Name extends string = string,
+> extends TuringWithShape<"ref", ShapeRef<Name>> {
+  name: Name;
+}
+
+export interface TuringBinop<
+  Op extends TuringOp = TuringOp,
+  Left extends TuringNode = TuringNode,
+  Right extends TuringNode = TuringNode,
+> extends TuringWithShape<"binop", ShapeUnknown> {
+  op: Op;
+  left: Left;
+  right: Right;
+}
+
+export type TuringNode =
+  | TuringNumber
+  | TuringBool
+  | TuringStr
+  | TuringDate
+  | TuringNil
+  | TuringRef
+  | TuringBinop;
+
+const makeBase = (): { __phantom: { out: any } } => {
+  return {} as unknown as any;
+};
+
+export namespace turing {
+  export const number = (x: number): TuringNumber => ({
+    type: "number",
+    value: x,
+    shape: shapes.number(),
+    ...makeBase(),
+  });
+
+  export const bool = (x: boolean): TuringBool => ({
+    type: "bool",
+    value: x,
+    shape: shapes.bool(),
+    ...makeBase(),
+  });
+
+  export const str = (x: string): TuringStr => ({
+    type: "str",
+    value: x,
+    shape: shapes.str(),
+    ...makeBase(),
+  });
+
+  export const date = (x: Date): TuringDate => ({
+    type: "date",
+    value: x,
+    shape: shapes.date(),
+    ...makeBase(),
+  });
+
+  export const nil = (): TuringNil => ({
+    type: "nil",
+    value: null,
+    shape: shapes.nil(),
+    ...makeBase(),
+  });
+
+  export function ref<Name extends string>(name: Name): TuringRef<Name> {
+    return {
+      type: "ref",
+      name: name,
+      shape: shapes.ref(name),
+      ...makeBase(),
+    };
+  }
+
+  export function binop<
+    Left extends TuringNode,
+    Op extends TuringOp,
+    Right extends TuringNode,
+  >(left: Left, op: Op, right: Right): TuringBinop<Op, Left, Right> {
+    return {
+      type: "binop",
+      left,
+      right,
+      op,
+      shape: shapes.unknown(),
+      ...makeBase(),
+    };
+  }
+
+  export function auto(x: unknown): TuringNode {
+    if (x === null) return nil();
+    if (typeof x === "undefined") return nil();
+    if (typeof x === "number") return number(x);
+    if (typeof x === "string") return str(x);
+    if (typeof x === "boolean") return bool(x);
+    return nil();
+  }
+}