[mod] extract all methods of Mod

TODO.md

@@ -1,5 +1,3 @@
-[mod] extract all methods of `Mod`
-
 [mod] `createMod` -- `Mod` should be a type -- instead of a class
 
 `NodeDefinition` should not have `rules` -- use `RuleDefinition`

src/lang/graph/netConnect.ts

@@ -1,7 +1,8 @@
 import { Action, Net, Port, createEdge } from "../graph"
+import { modLookupRuleByPorts } from "../mod/modLookupRuleByPorts"
 
 export function netConnect(net: Net, start: Port, end: Port): void {
-  const rule = net.mod.lookupRuleByPorts(start, end)
+  const rule = modLookupRuleByPorts(net.mod, start, end)
 
   if (rule) {
     net.actions.push(new Action(start, end, rule))

src/lang/mod/Mod.ts

@@ -1,7 +1,4 @@
 import { Definition } from "../definition"
-import * as Definitions from "../definitions"
-import { Port } from "../graph"
-import { Rule } from "../rule"
 import { defineBuiltInOperators } from "./defineBuiltInOperators"
 
 export class Mod {
@@ -10,41 +7,4 @@ export class Mod {
   constructor(public url: URL) {
     defineBuiltInOperators(this)
   }
-
-  lookupDefinitionOrFail(name: string): Definition {
-    const definition = this.definitions.get(name)
-    if (definition === undefined) {
-      throw new Error(`Undefined name: ${name}`)
-    }
-
-    return definition
-  }
-
-  lookupNodeDefinitionOrFail(name: string): Definitions.NodeDefinition {
-    const definition = this.lookupDefinitionOrFail(name)
-    if (!(definition instanceof Definitions.NodeDefinition)) {
-      throw new Error(
-        `I expect a node definition, but ${name} is ${definition.constructor.name}`,
-      )
-    }
-
-    return definition
-  }
-
-  lookupNetDefinitionOrFail(name: string): Definitions.NetDefinition {
-    const definition = this.lookupDefinitionOrFail(name)
-    if (!(definition instanceof Definitions.NetDefinition)) {
-      throw new Error(
-        `I expect a net definition, but ${name} is ${definition.constructor.name}`,
-      )
-    }
-
-    return definition
-  }
-
-  lookupRuleByPorts(start: Port, end: Port): Rule | undefined {
-    if (start.isPrincipal && end.isPrincipal) {
-      return start.node.definition.lookupRule(end.node.definition)
-    }
-  }
 }

src/lang/mod/modBuildNet.ts

@@ -2,10 +2,11 @@ import { Net } from "../graph"
 import { createNet } from "../graph/createNet"
 import { netCleanUpWires } from "../graph/netCleanUpWires"
 import { Mod } from "./Mod"
+import { modLookupNetDefinitionOrFail } from "./modLookupNetDefinitionOrFail"
 
 export function modBuildNet(mod: Mod, name: string): Net {
   const net = createNet(mod)
-  mod.lookupNetDefinitionOrFail(name).meaning(net)
+  modLookupNetDefinitionOrFail(mod, name).meaning(net)
   netCleanUpWires(net)
   return net
 }

src/lang/mod/modLookupDefinitionOrFail.ts

@@ -0,0 +1,11 @@
+import { Definition } from "../definition"
+import { Mod } from "./Mod"
+
+export function modLookupDefinitionOrFail(mod: Mod, name: string): Definition {
+  const definition = mod.definitions.get(name)
+  if (definition === undefined) {
+    throw new Error(`Undefined name: ${name}`)
+  }
+
+  return definition
+}

src/lang/mod/modLookupNetDefinitionOrFail.ts

@@ -0,0 +1,17 @@
+import * as Definitions from "../definitions"
+import { Mod } from "./Mod"
+import { modLookupDefinitionOrFail } from "./modLookupDefinitionOrFail"
+
+export function modLookupNetDefinitionOrFail(
+  mod: Mod,
+  name: string,
+): Definitions.NetDefinition {
+  const definition = modLookupDefinitionOrFail(mod, name)
+  if (!(definition instanceof Definitions.NetDefinition)) {
+    throw new Error(
+      `I expect a net definition, but ${name} is ${definition.constructor.name}`,
+    )
+  }
+
+  return definition
+}

src/lang/mod/modLookupNodeDefinitionOrFail.ts

@@ -0,0 +1,17 @@
+import * as Definitions from "../definitions"
+import { Mod } from "./Mod"
+import { modLookupDefinitionOrFail } from "./modLookupDefinitionOrFail"
+
+export function modLookupNodeDefinitionOrFail(
+  mod: Mod,
+  name: string,
+): Definitions.NodeDefinition {
+  const definition = modLookupDefinitionOrFail(mod, name)
+  if (!(definition instanceof Definitions.NodeDefinition)) {
+    throw new Error(
+      `I expect a node definition, but ${name} is ${definition.constructor.name}`,
+    )
+  }
+
+  return definition
+}

src/lang/mod/modLookupRuleByPorts.ts

@@ -0,0 +1,13 @@
+import { Port } from "../graph"
+import { Rule } from "../rule"
+import { Mod } from "./Mod"
+
+export function modLookupRuleByPorts(
+  mod: Mod,
+  start: Port,
+  end: Port,
+): Rule | undefined {
+  if (start.isPrincipal && end.isPrincipal) {
+    return start.node.definition.lookupRule(end.node.definition)
+  }
+}

src/lang/stmts/DefruleStmt.ts

@@ -1,4 +1,5 @@
 import { Mod } from "../mod"
+import { modLookupNodeDefinitionOrFail } from "../mod/modLookupNodeDefinitionOrFail"
 import { Rule } from "../rule"
 import { Span } from "../span"
 import { Stmt } from "../stmt"
@@ -15,8 +16,8 @@ export class DefruleStmt extends Stmt {
   }
 
   async execute(mod: Mod): Promise<void> {
-    const startNodeDefinition = mod.lookupNodeDefinitionOrFail(this.start)
-    const endNodeDefinition = mod.lookupNodeDefinitionOrFail(this.end)
+    const startNodeDefinition = modLookupNodeDefinitionOrFail(mod, this.start)
+    const endNodeDefinition = modLookupNodeDefinitionOrFail(mod, this.end)
 
     startNodeDefinition.defineRule(
       endNodeDefinition,

src/lang/words/Call.ts

@@ -1,5 +1,6 @@
 import { Net } from "../graph"
 import { Mod } from "../mod"
+import { modLookupDefinitionOrFail } from "../mod/modLookupDefinitionOrFail"
 import { Span } from "../span"
 import { Word } from "../word"
 
@@ -17,7 +18,7 @@ export class Call extends Word {
       net.portStore.delete(this.name)
       net.portStack.push(found)
     } else {
-      mod.lookupDefinitionOrFail(this.name).meaning(net)
+      modLookupDefinitionOrFail(mod, this.name).meaning(net)
     }
   }
 }