core: reorganize / improve definition of basic functions

scopes/core/core.py

@@ -26,12 +26,30 @@ type Handler = Callable[[Message, Scope],
 type Handlers = Handler | None | list[Handlers]
 type Actions = dict[Symbol, Handlers]
 
-async def proc_dummy(msg: Message, scope: Scope) -> None:
+env_dummy: Mailbox = asyncio.Queue()
-    await scope.environ.put(msg)
 
-global_mailbox: Mailbox = asyncio.Queue()
+def notify() -> Handler:
+    async def handle(msg, scope) -> None:
+        await scope.environ.put(msg)
+    return handle
 
-def gen_program(spec: ProgramSpec, default: Proc = proc_dummy) -> Program:
+def gen_proc(actions: Actions, default: Handlers = notify(),
+             prepare: Handlers = None, finalize: Handlers = None) -> Proc:
+    async def proc(msg: Message, scope: Scope) -> Scope:
+        acts = actions.get(msg.head['action'], actions.get(k.default, default))
+        acts = util.flatten(prepare, acts, finalize, ignore_none=True)
+        for act in acts:
+            msg = await act(msg, scope)
+            if isinstance(msg, tuple):
+                msg, new_scope = msg
+                if new_scope is not None:
+                    scope = new_scope
+            if msg is None:
+                break
+        return scope
+    return proc
+
+def gen_program(spec: ProgramSpec, default: Proc = gen_proc({})) -> Program:
     def program(scope: Scope) -> Proc:
         key = (scope.categ[1], scope.stage)
         proc = spec.get(key, spec.get((key[0], k.default)))
@@ -49,7 +67,7 @@ class Scope:
     proc: Proc = field(init=False)
     program: Program = gen_program({})
     syns: list[Syn] = field(default_factory=list)
-    environ: Mailbox = global_mailbox
+    environ: Mailbox = env_dummy
 
     def __post_init__(self):
         self.set_proc()
@@ -75,29 +93,14 @@ def create_zero(env: Mailbox) -> Mailbox:
 
 def synapse(rcvr: Mailbox, op: SynOp = lambda x: x) -> Syn:
     async def syn(msg: Message) -> None:
-        # op = update_op(msg)
+        # op = update_op(msg) (=> return?)
+        # rv = check_return(msg) => return rv
         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,
+def std_proc(actions: Actions) -> Proc:
-             prepare: Handlers = None, finalize: Handlers = None) -> Proc:
-    async def proc(msg: Message, scope: Scope) -> Scope:
-        acts = actions.get(msg.head['action'], actions.get(k.default, default))
-        acts = util.flatten(prepare, acts, finalize, ignore_none=True)
-        for act in acts:
-            msg = await act(msg, scope)
-            if isinstance(msg, tuple):
-                msg, new_scope = msg
-                if new_scope is not None:
-                    scope = new_scope
-            if msg is None:
-                break
-        return scope
-    return proc
-
-def gen_std(actions: Actions) -> Proc:
     return gen_proc(actions, finalize=forward())
 
 def basic_actions() -> Actions:
@@ -110,18 +113,18 @@ def basic_actions() -> Actions:
 # predefined action handlers
 
 def forward() -> Handler:
-    async def do_forward(msg, scope) -> None:
+    async def handle(msg, scope) -> None:
         for syn in scope.syns:
             await syn(msg)
-    return do_forward
+    return handle
 
 def value_add() -> Handler:
-    async def do_add(msg, scope) -> tuple[Message, Scope]:
+    async def handle(msg, scope) -> tuple[Message, Scope]:
         return msg, scope
-    return do_add
+    return handle
 
 def create() -> Handler:
-    async def do_create(msg, scope) -> None:
+    async def handle(msg, scope) -> None:
         return None
-    return do_create
+    return handle
 

scopes/core/environ.py

@@ -7,10 +7,12 @@ from scopes.core import actor
 from scopes.core.message import Message
 from scopes.util import keywords as k
 
-async def proc_env(msg: Message, scope: core.Scope) -> None:
+def program_env(scope: core.Scope) -> core.Proc:
-    await scope.environ.put(msg)
+    async def proc(msg: Message, scope: core.Scope) -> None:
+        await scope.environ.put(msg)
+    return proc
 
-def create(meta_env: core.Mailbox) -> core.Mailbox:
+def create(meta_env: core.Mailbox, prog: core.Program = program_env) -> core.Mailbox:
-    scope = core.create_scope(meta_env, (k.env, k.c00), program=lambda x: proc_env)
+    scope = core.create_scope(meta_env, (k.env, k.c00), program=prog)
     return core.neuron(scope)