core: synapse implementation (with op for changing or cancelling msg)

scopes/core/core.py

@@ -17,7 +17,9 @@ type Mailbox = asyncio.Queue
 type Categ = tuple[Symbol, Symbol]
 type Proc = Callable[[Message, Scope], Awaitable[Scope | None]]
 type Program = Callable[[Scope], Proc]
-type Syn = Callable[[Message], Message]
+type ProgramSpec = dict[tuple[Symbol, Symbol], Proc]
+type Syn = Callable[[Message], Awaitable[None]]
+type SynOp = Callable[[Message], Message | None]
 
 type Handler = Callable[[Message, Scope], 
      Awaitable[Message | None | tuple[Message | None, Scope | None]]]
@@ -29,6 +31,15 @@ async def proc_dummy(msg: Message, scope: Scope) -> None:
 
 global_mailbox: Mailbox = asyncio.Queue()
 
+def gen_program(spec: ProgramSpec, default: Proc = proc_dummy) -> Program:
+    def program(scope: Scope) -> Proc:
+        key = (scope.categ[1], scope.stage)
+        proc = spec.get(key, spec.get((key[0], k.default)))
+        if proc is None:
+            proc = spec.get((k.default, key[1]), default)
+        return proc
+    return program
+
 @dataclass
 class Scope:
 
@@ -36,7 +47,7 @@ class Scope:
     categ: Categ = (k.csys, k.c00)
     stage: Symbol = k.initial
     proc: Proc = field(init=False)
-    program: Program = lambda x: proc_dummy
+    program: Program = gen_program({})
     syns: list[Syn] = field(default_factory=list)
     environ: Mailbox = global_mailbox
 
@@ -62,6 +73,13 @@ def create_zero(env: Mailbox) -> Mailbox:
     zero = neuron(scope)
     return zero
 
+def synapse(rcvr: Mailbox, op: SynOp = lambda x: x) -> Syn:
+    async def syn(msg: Message) -> None:
+        msg_new = op(msg)
+        if msg_new is not None:
+            await rcvr.put(msg_new)
+    return syn
+
 def gen_proc(actions: Actions, default: Handlers = None,
              before: Handlers = None, after: Handlers = None) -> Proc:
     async def proc(msg: Message, scope: Scope) -> Scope: