core: std_proc; rearrange definitions for clarity and other improvments

scopes/core/core.py

@@ -58,6 +58,22 @@ def gen_program(spec: ProgramSpec, default: Proc = gen_proc({})) -> Program:
         return proc
     return program
 
+def neuron(scope: Scope) -> Mailbox:
+    async def process(msg: Message) -> actor.Behavior | None:
+        nonlocal scope
+        scope = await scope.proc(msg, scope) or scope
+        return process
+    return actor.create(process)
+
+def synapse(rcvr: Mailbox, op: SynOp = lambda x: x) -> Syn:
+    async def syn(msg: Message) -> None:
+        # 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
+
 @dataclass
 class Scope:
 
@@ -79,38 +95,12 @@ class Scope:
 def create_scope(env: Mailbox, cat: Categ = (k.csys, k.c00), **kw) -> Scope:
     return Scope(environ=env, categ=cat, **kw)
 
-def neuron(scope: Scope) -> Mailbox:
-    async def process(msg: Message) -> actor.Behavior | None:
-        nonlocal scope
-        scope = await scope.proc(msg, scope) or scope
-        return process
-    return actor.create(process)
-
 def create_zero(env: Mailbox) -> Mailbox:
     scope = create_scope(env)
     zero = neuron(scope)
     return zero
 
-def synapse(rcvr: Mailbox, op: SynOp = lambda x: x) -> Syn:
+# predefined action handlers and Action sets
-    async def syn(msg: Message) -> None:
-        # 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 std_proc(actions: Actions) -> Proc:
-    return gen_proc(actions, finalize=forward())
-
-def basic_actions() -> Actions:
-    acts: Actions = {
-        k.value: value_add(),
-        k.create: create()
-    }
-    return acts
-
-# predefined action handlers
 
 def forward() -> Handler:
     async def handle(msg, scope) -> None:
@@ -128,3 +118,18 @@ def create() -> Handler:
         return None
     return handle
 
+def basic_actions() -> Actions:
+    acts: Actions = {
+        k.value: value_add(),
+        k.create: create()
+    }
+    return acts
+
+# predefined specialized procs
+
+def std_proc(actions: Actions | None = None, finalize=forward(), **kw) -> Proc:
+    if actions is None:
+        act_add = dict((k(key), val) for key, val in kw.items())
+        actions = basic_actions() | act_add
+    return gen_proc(actions, finalize=finalize)
+

scopes/core/environ.py

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