createNode take net and create nodePorts

- use `findNodePortsOrFail` instead of `findNodePortsOrCreate`

TODO.md

@@ -1,10 +1,8 @@
 # net -- graph theory
 
-`createNode` take `net` and create `nodePorts`
-
 rename `node/createNode` to `net/addNode`
 
-use `findNodePortsOrFail` instead of `findNodePortsOrCreate`
+rename `placeholder/create*` to `placeholder/add*`
 
 `Node` should not `input` and `output` ports
 

src/lang/check/checkRule.ts

@@ -16,18 +16,22 @@ export function checkRule(
 ): void {
   const checking = createChecking()
 
-  const first = createNodeFromDefinition(lookupDefinitionOrFail(mod, firstName))
+  const env = createEnv(mod)
+
+  const first = createNodeFromDefinition(
+    env.net,
+    lookupDefinitionOrFail(mod, firstName),
+  )
 
   refreshNode(checking.typeVarCounters, first)
 
   const second = createNodeFromDefinition(
+    env.net,
     lookupDefinitionOrFail(mod, secondName),
   )
 
   refreshNode(checking.typeVarCounters, second)
 
-  const env = createEnv(mod)
-
   connectNodeWithPlaceholderPorts(mod, env.net, first)
   connectNodeWithPlaceholderPorts(mod, env.net, second)
 

src/lang/check/checkRuleNodeOrder.ts

@@ -1,13 +1,23 @@
 import { Mod } from "../mod"
 import { lookupDefinitionOrFail } from "../mod/lookupDefinitionOrFail"
-import { createNodeFromDefinition } from "../node/createNodeFromDefinition"
 
 export function checkRuleNodeOrder(
   mod: Mod,
   firstName: string,
   secondName: string,
 ): void {
-  const first = createNodeFromDefinition(lookupDefinitionOrFail(mod, firstName))
+  const first = lookupDefinitionOrFail(mod, firstName)
+
+  if (first["@kind"] !== "NodeDefinition") {
+    throw new Error(
+      [
+        `[checkRuleNodeOrder] I expect the first name to be a NodeDefinition.`,
+        ``,
+        ` first node: ${firstName}`,
+        ` second node: ${secondName}`,
+      ].join("\n"),
+    )
+  }
 
   if (!first.output.some((port) => port.isPrincipal)) {
     throw new Error(
@@ -20,9 +30,18 @@ export function checkRuleNodeOrder(
     )
   }
 
-  const second = createNodeFromDefinition(
-    lookupDefinitionOrFail(mod, secondName),
-  )
+  const second = lookupDefinitionOrFail(mod, secondName)
+
+  if (second["@kind"] !== "NodeDefinition") {
+    throw new Error(
+      [
+        `[checkRuleNodeOrder] I expect the first name to be a NodeDefinition.`,
+        ``,
+        ` first node: ${firstName}`,
+        ` second node: ${secondName}`,
+      ].join("\n"),
+    )
+  }
 
   if (!second.input.some((port) => port.isPrincipal)) {
     throw new Error(

src/lang/check/checkWords.ts

@@ -25,7 +25,7 @@ export function checkWords(
 
   const placeholderOutputPorts = inputValues
     .reverse()
-    .map((t) => createPlaceholderOutputPortFromType(mod, t))
+    .map((t) => createPlaceholderOutputPortFromType(env.net, mod, t))
 
   env.stack.push(...placeholderOutputPorts)
 

src/lang/compose/compose.ts

@@ -157,10 +157,15 @@ export function compose(
 
       case "NodeRearrange": {
         const definition = lookupDefinitionOrFail(mod, word.name)
-        composeNode(env, createNodeFromDefinition(definition), options, {
-          input: word.input,
-          output: word.output,
-        })
+        composeNode(
+          env,
+          createNodeFromDefinition(env.net, definition),
+          options,
+          {
+            input: word.input,
+            output: word.output,
+          },
+        )
 
         return
       }

src/lang/compose/composeDefinition.ts

@@ -15,7 +15,7 @@ export function composeDefinition(
 ): void {
   switch (definition["@kind"]) {
     case "NodeDefinition": {
-      composeNode(env, createNodeFromDefinition(definition), options)
+      composeNode(env, createNodeFromDefinition(env.net, definition), options)
       return
     }
 

src/lang/connect/connect.ts

@@ -1,7 +1,7 @@
 import { checkPortSigns } from "../check/checkPortSigns"
 import { lookupRuleByPorts } from "../mod/lookupRuleByPorts"
 import { Net } from "../net"
-import { findNodePortsOrCreate } from "../net/findNodePortsOrCreate"
+import { findNodePortsOrFail } from "../net/findNodePortsOrFail"
 import { findPortConnection } from "../net/findPortConnection"
 import { Port } from "../port"
 import { formatValue } from "../value/formatValue"
@@ -36,20 +36,20 @@ export function connect(net: Net, first: Port, second: Port): void {
   if (rule !== undefined) {
     const edge = { first, second, rule }
 
-    const firstNodePorts = findNodePortsOrCreate(net, first.node)
+    const firstNodePorts = findNodePortsOrFail(net, first.node)
     firstNodePorts[first.name] = { edge, port: second }
 
-    const secondNodePorts = findNodePortsOrCreate(net, second.node)
+    const secondNodePorts = findNodePortsOrFail(net, second.node)
     secondNodePorts[second.name] = { edge, port: first }
 
     net.activeEdges.push(edge)
   } else {
     const edge = { first, second }
 
-    const firstNodePorts = findNodePortsOrCreate(net, first.node)
+    const firstNodePorts = findNodePortsOrFail(net, first.node)
     firstNodePorts[first.name] = { edge, port: second }
 
-    const secondNodePorts = findNodePortsOrCreate(net, second.node)
+    const secondNodePorts = findNodePortsOrFail(net, second.node)
     secondNodePorts[second.name] = { edge, port: first }
 
     net.edges.push(edge)

src/lang/net/findNodePortsOrCreate.ts → src/lang/net/findNodePortsOrFail.ts

@@ -1,15 +1,21 @@
 import { Node } from "../node"
+import { formatNode } from "../node/formatNode"
 import { nodeKeyId } from "../node/nodeKeyId"
 import { Net, PortConnection } from "./Net"
 
-export function findNodePortsOrCreate(
+export function findNodePortsOrFail(
   net: Net,
   node: Node,
 ): Record<string, PortConnection> {
   let ports = net.nodePorts.get(nodeKeyId(node))
   if (ports === undefined) {
-    ports = {}
-    net.nodePorts.set(nodeKeyId(node), ports)
+    throw new Error(
+      [
+        `[findNodePortsOrFail] I can not find nodePorts for node.`,
+        ``,
+        `  node: ${formatNode(node)}`,
+      ].join("\n"),
+    )
   }
 
   return ports

src/lang/node/createNode.ts

@@ -1,11 +1,14 @@
 import { Mod } from "../mod"
+import { Net } from "../net"
 import { Node } from "../node"
 import { PortExp } from "../port/PortExp"
 import { createInputPort } from "../port/createInputPort"
 import { createOutputPort } from "../port/createOutputPort"
 import { createNodeId } from "./createNodeId"
+import { nodeKeyId } from "./nodeKeyId"
 
 export function createNode(
+  net: Net,
   mod: Mod,
   name: string,
   input: Array<PortExp>,
@@ -19,6 +22,8 @@ export function createNode(
     output: [],
   }
 
+  net.nodePorts.set(nodeKeyId(node), {})
+
   node.input = input.map((port) => createInputPort(node, port))
   node.output = output.map((port) => createOutputPort(node, port))
 

src/lang/node/createNodeFromDefinition.ts

@@ -1,8 +1,12 @@
 import { Definition } from "../definition"
+import { Net } from "../net"
 import { Node } from "../node"
 import { createNode } from "../node/createNode"
 
-export function createNodeFromDefinition(definition: Definition): Node {
+export function createNodeFromDefinition(
+  net: Net,
+  definition: Definition,
+): Node {
   if (definition["@kind"] !== "NodeDefinition") {
     throw new Error(
       [
@@ -14,6 +18,7 @@ export function createNodeFromDefinition(definition: Definition): Node {
   }
 
   return createNode(
+    net,
     definition.mod,
     definition.name,
     definition.input,

src/lang/placeholder/connectNodeWithPlaceholderPorts.ts

@@ -12,14 +12,14 @@ export function connectNodeWithPlaceholderPorts(
 ): void {
   for (const port of node.input) {
     if (!port.isPrincipal) {
-      const placeholderPort = createPlaceholderOutputPortForPort(mod, port)
+      const placeholderPort = createPlaceholderOutputPortForPort(net, mod, port)
       connect(net, port, placeholderPort)
     }
   }
 
   for (const port of node.output) {
     if (!port.isPrincipal) {
-      const placeholderPort = createPlaceholderInputPortForPort(mod, port)
+      const placeholderPort = createPlaceholderInputPortForPort(net, mod, port)
       connect(net, port, placeholderPort)
     }
   }

src/lang/placeholder/createPlaceholderInputPortForPort.ts

@@ -1,11 +1,17 @@
 import { Mod } from "../mod"
+import { Net } from "../net"
 import { createNode } from "../node/createNode"
 import { Port } from "../port"
 
-export function createPlaceholderInputPortForPort(mod: Mod, port: Port): Port {
+export function createPlaceholderInputPortForPort(
+  net: Net,
+  mod: Mod,
+  port: Port,
+): Port {
   const nodeName = `_placeholder_input_node_for_${port.name}_of_${port.node.name}`
   const portName = `_placeholder_input_port_for_${port.name}_of_${port.node.name}`
   const node = createNode(
+    net,
     mod,
     nodeName,
     [

src/lang/placeholder/createPlaceholderOutputPortForPort.ts

@@ -1,11 +1,17 @@
 import { Mod } from "../mod"
+import { Net } from "../net"
 import { createNode } from "../node/createNode"
 import { Port } from "../port"
 
-export function createPlaceholderOutputPortForPort(mod: Mod, port: Port): Port {
+export function createPlaceholderOutputPortForPort(
+  net: Net,
+  mod: Mod,
+  port: Port,
+): Port {
   const nodeName = `_placeholder_output_node_for_${port.name}_of_${port.node.name}`
   const portName = `_placeholder_output_port_for_${port.name}_of_${port.node.name}`
   const node = createNode(
+    net,
     mod,
     nodeName,
     [],

src/lang/placeholder/createPlaceholderOutputPortFromType.ts

@@ -1,12 +1,18 @@
 import { Mod } from "../mod"
+import { Net } from "../net"
 import { createNode } from "../node/createNode"
 import { Port } from "../port"
 import { Value } from "../value"
 
-export function createPlaceholderOutputPortFromType(mod: Mod, t: Value): Port {
+export function createPlaceholderOutputPortFromType(
+  net: Net,
+  mod: Mod,
+  t: Value,
+): Port {
   const nodeName = `_placeholder_output_node_from_type`
   const portName = `_placeholder_output_port_from_type`
   const node = createNode(
+    net,
     mod,
     nodeName,
     [],

src/lang/run/closeFreePorts.ts

@@ -26,7 +26,13 @@ export function closeFreePorts(env: Env): Node | undefined {
       isPrincipal: false,
     }))
 
-  const node = createNode(env.mod, "_temporary_closing_node", ports, [])
+  const node = createNode(
+    env.net,
+    env.mod,
+    "_temporary_closing_node",
+    ports,
+    [],
+  )
 
   return composeNode(env, node, {})
 }