inferencing on return types

Author: Sheyne

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "test-support/circuits"]
 	path = test-support/circuits
 	url = https://github.com/2graphic/circuits-plugin.git
+[submodule "test-support/bfs"]
+	path = test-support/bfs
+	url = https://github.com/Sheyne/sinap-bfs-plugin

package.json

@@ -1,7 +1,7 @@
 {
   "name": "sinap-typescript",
   "description": "Bindings for synap-types from typescript",
-  "version": "0.4.14",
+  "version": "0.4.15",
   "readme": "README.md",
   "license": "MIT",
   "repository": {

src/natural.ts

@@ -203,7 +203,7 @@ export function valueToNatural(prototypes: Map<Type.CustomObject | Type.Intersec
 export function naturalToValue(environment: Value.Environment, typeMap: Iterable<[Function, Type.Type]>) {
     const map = new Map([...typeMap].map(([a, b]) => [a.prototype, b] as [any, Type.Type]));
     const transformations = new Map<any, Value.Value>();
-    return function(value: any) {
-        return toValueInner(value, environment, map, transformations, undefined);
+    return function(value: any, knownType?: Type.Type) {
+        return toValueInner(value, environment, map, transformations, knownType);
     };
 }

src/program.ts

@@ -7,7 +7,7 @@ import { naturalToValue } from "./natural";
 
 export class TypescriptProgram implements Core.Program {
     readonly model: Model;
-    readonly toValue: (a: any) => Value.Value;
+    readonly toValue: (a: any, knownType?: Type.Type) => Value.Value;
 
     constructor(modelIn: Model, public plugin: TypescriptPlugin) {
         this.model = Model.fromSerial(modelIn.serialize(), plugin);
@@ -62,14 +62,30 @@ export class TypescriptProgram implements Core.Program {
         const steps: Value.CustomObject[] = [];
 
         while (state instanceof this.plugin.naturalStateType) {
-            steps.push(this.toValue(state) as Value.CustomObject);
+            steps.push(this.toValue(state, this.plugin.types.state) as Value.CustomObject);
             try {
                 state = this.plugin.implementation.step(state);
             } catch (err) {
                 return { steps: steps, error: Value.makePrimitive(this.model.environment, err) };
             }
         }
-        return { steps: steps, result: this.toValue(state) };
+
+        // TODO: fixup
+        let res: Value.Value;
+        if (this.plugin.types.result instanceof Type.Union) FoundAResult: {
+            for (const type of this.plugin.types.result.types) {
+                try {
+                    res = this.toValue(state, type);
+                    break FoundAResult;
+                } catch (err) {
+                }
+            }
+            throw new Error("no types worked");
+        } else {
+            res = this.toValue(state, this.plugin.types.result);
+        }
+
+        return { steps: steps, result: res };
     }
 
     validate() {

src/test-plugins.ts

@@ -4,6 +4,7 @@ import * as path from "path";
 import { expect } from "chai";
 import { Type, Value } from "sinap-types";
 import { TypescriptPlugin } from "./plugin";
+import { imap } from "sinap-types/lib/util";
 
 function verifyReserial(m1: Model, p: Plugin) {
     const s1 = m1.serialize();
@@ -16,6 +17,12 @@ function verifyReserial(m1: Model, p: Plugin) {
     expect(s3).to.deep.equal(s2);
 }
 
+function node(label: string, model: Model) {
+    const node = model.makeNode();
+    node.set("label", new Value.Primitive(new Type.Primitive("string"), model.environment, label));
+    return node;
+}
+
 describe("Actual Plugins", () => {
     const loader = new TypescriptPluginLoader();
     async function loadPlugin(...p: string[]) {
@@ -32,11 +39,9 @@ describe("Actual Plugins", () => {
         const plugin = await loadPlugin("test-support", "turing-machine");
 
         const model = new Model(plugin);
-        const q1 = model.makeNode();
-        q1.set("label", new Value.Primitive(new Type.Primitive("string"), model.environment, "q1"));
+        const q1 = node("q1", model);
         q1.set("isStartState", new Value.Primitive(new Type.Primitive("boolean"), model.environment, true));
-        const q2 = model.makeNode();
-        q2.set("label", new Value.Primitive(new Type.Primitive("string"), model.environment, "q2"));
+        const q2 = node("q1", model);
         q2.set("isAcceptState", new Value.Primitive(new Type.Primitive("boolean"), model.environment, true));
 
         const edge = model.makeEdge(undefined, q1, q2);
@@ -105,6 +110,30 @@ describe("Actual Plugins", () => {
         const prog = plugin.makeProgram(model);
         prog.validate();
 
+        verifyReserial(model, plugin);
+    });
+    it("loads BFS", async () => {
+        const plugin = await loadPlugin("test-support", "bfs");
+
+        const model = new Model(plugin);
+        const n1 = node("q1", model);
+        model.makeEdge(undefined, n1, node("q2", model));
+
+        const prog = plugin.makeProgram(model);
+        prog.validate();
+
+        const res = await prog.run([prog.model.environment.values.get(n1.uuid)!]);
+        const result = res.result as Value.ArrayObject;
+        expect(result).to.instanceof(Value.ArrayObject);
+
+        const values = [...imap((value) => {
+            expect(value).to.instanceof(Value.CustomObject);
+            const label = (value as Value.CustomObject).get("label") as Value.Primitive;
+            expect(label).to.instanceof(Value.Primitive);
+            return label.value;
+        }, result)];
+        expect(values).to.deep.equal(["q1", "q2"]);
+
         verifyReserial(model, plugin);
     });
 });