extract compose

- let `Word` be algebraic data type

TODO.md

@@ -1,9 +1,5 @@
 # type
 
-extract `compose`
-
-- let `Word` be algebraic data type
-
 extract `cut`
 
 `defrule` -- check type -- cut -- words composition

src/lang/compose/compose.ts

@@ -1,6 +1,10 @@
 import { Node } from "../graph"
+import { findPortInNodes } from "../graph/findPortInActiveEdge"
 import { Mod } from "../mod"
+import { lookupDefinitionOrFail } from "../mod/lookupDefinitionOrFail"
 import { Net } from "../net"
+import { connect } from "../net/connect"
+import { disconnect } from "../net/disconnect"
 import { Word } from "../word"
 
 export interface ComposeOptions {
@@ -13,5 +17,97 @@ export function compose(
   word: Word,
   options?: ComposeOptions,
 ): void {
-  //
+  switch (word.kind) {
+    case "Call": {
+      const found = net.localPorts.get(word.name)
+      if (found !== undefined) {
+        net.ports.push(found)
+        net.localPorts.delete(word.name)
+        return
+      } else {
+        lookupDefinitionOrFail(mod, word.name).compose(net)
+        return
+      }
+    }
+
+    case "LocalSet": {
+      const port = net.ports.pop()
+      if (port === undefined) {
+        throw new Error(
+          `[LocalSet.compose] expect a port on the top of the stack`,
+        )
+      }
+
+      net.localPorts.set(word.name, port)
+      return
+    }
+
+    case "PortPush": {
+      const { current } = options || {}
+
+      if (current === undefined) {
+        throw new Error(`[PortPush.compose] expect current activeEdge`)
+      }
+
+      const found = findPortInNodes(word.nodeName, word.portName, [
+        current.start,
+        current.end,
+      ])
+
+      if (found === undefined) {
+        throw new Error(
+          `[PortPush.compose] can not find port: ${word.portName} in active edge`,
+        )
+      }
+
+      if (found.connection === undefined) {
+        throw new Error(
+          `[PortPush.compose] I expect the found port to have connection`,
+        )
+      }
+
+      disconnect(net, found.connection.edge)
+
+      net.ports.push(found)
+
+      return
+    }
+
+    case "PortReconnect": {
+      const { current } = options || {}
+
+      if (current === undefined) {
+        throw new Error(`[PortReconnect.compose] expect current activeEdge`)
+      }
+
+      const found = findPortInNodes(word.nodeName, word.portName, [
+        current.start,
+        current.end,
+      ])
+
+      if (found === undefined) {
+        throw new Error(
+          `[PortReconnect.compose] can not find port: ${word.portName} in active edge`,
+        )
+      }
+
+      if (found.connection === undefined) {
+        throw new Error(
+          `[PortReconnect.compose] I expect the found port to have connection`,
+        )
+      }
+
+      disconnect(net, found.connection.edge)
+
+      const topPort = net.ports.pop()
+
+      if (topPort === undefined) {
+        throw new Error(`[PortReconnect.compose] expect top port`)
+      }
+
+      connect(net, topPort, found)
+
+      return
+    }
+  }
 }

src/lang/compose/composeWords.ts

@@ -2,10 +2,11 @@ import { Mod } from "../mod"
 import { Net } from "../net"
 import { cleanUpWires } from "../net/cleanUpWires"
 import { Word } from "../word"
+import { compose } from "./compose"
 
 export function composeWords(mod: Mod, net: Net, words: Array<Word>): void {
   for (const word of words) {
-    word.compose(mod, net)
+    compose(mod, net, word)
   }
 
   cleanUpWires(net)

src/lang/run/interact.ts

@@ -1,3 +1,4 @@
+import { compose } from "../compose/compose"
 import { ActiveEdge } from "../graph"
 import { Mod } from "../mod"
 import { Net } from "../net"
@@ -8,7 +9,7 @@ export function interact(mod: Mod, net: Net, activeEdge: ActiveEdge): void {
   removeNodeAndEdges(net, activeEdge.start.node)
 
   for (const word of activeEdge.rule.words) {
-    word.compose(mod, net, {
+    compose(mod, net, word, {
       current: {
         start: activeEdge.start.node,
         end: activeEdge.end.node,

src/lang/syntax/matchers/word_matcher.ts

@@ -1,16 +1,16 @@
 import * as pt from "@cicada-lang/partech"
+import * as Words from "../../word"
 import { Word } from "../../word"
-import * as Words from "../../words"
 
 export function word_matcher(tree: pt.Tree): Word {
   return pt.matcher<Word>({
-    "word:call": ({ name }, { span }) => new Words.Call(pt.str(name), span),
+    "word:call": ({ name }, { span }) => Words.Call(pt.str(name), span),
     "word:local_set": ({ name }, { span }) =>
-      new Words.LocalSet(pt.str(name), span),
+      Words.LocalSet(pt.str(name), span),
     "word:port_push": ({ nodeName, portName }, { span }) =>
-      new Words.PortPush(pt.str(nodeName), pt.str(portName), span),
+      Words.PortPush(pt.str(nodeName), pt.str(portName), span),
     "word:port_reconnect": ({ nodeName, portName }, { span }) =>
-      new Words.PortReconnect(pt.str(nodeName), pt.str(portName), span),
+      Words.PortReconnect(pt.str(nodeName), pt.str(portName), span),
   })(tree)
 }
 

src/lang/word/Word.ts

@@ -1,13 +1,71 @@
-import { Node } from "../graph"
-import { Mod } from "../mod"
-import { Net } from "../net"
 import { Span } from "../span"
 
-export interface ComposeOptions {
-  current?: { start: Node; end: Node }
+export type Word = Call | LocalSet | PortPush | PortReconnect
+
+export type Call = {
+  kind: "Call"
+  name: string
+  span: Span
+}
+
+export function Call(name: string, span: Span): Call {
+  return {
+    kind: "Call",
+    name,
+    span,
+  }
+}
+
+export type LocalSet = {
+  kind: "LocalSet"
+  name: string
+  span: Span
+}
+
+export function LocalSet(name: string, span: Span): LocalSet {
+  return {
+    kind: "LocalSet",
+    name,
+    span,
+  }
+}
+
+export type PortPush = {
+  kind: "PortPush"
+  nodeName: string
+  portName: string
+  span: Span
 }
 
-export interface Word {
+export function PortPush(
+  nodeName: string,
+  portName: string,
+  span: Span,
+): PortPush {
+  return {
+    kind: "PortPush",
+    nodeName,
+    portName,
+    span,
+  }
+}
+
+export type PortReconnect = {
+  kind: "PortReconnect"
+  nodeName: string
+  portName: string
   span: Span
-  compose(mod: Mod, net: Net, options?: ComposeOptions): void
+}
+
+export function PortReconnect(
+  nodeName: string,
+  portName: string,
+  span: Span,
+): PortReconnect {
+  return {
+    kind: "PortReconnect",
+    nodeName,
+    portName,
+    span,
+  }
 }