scopes/core/core.py

@@ -8,7 +8,6 @@ from collections.abc import Awaitable, Callable, Coroutine
 from dataclasses import dataclass, field
 from typing import Any
 
-from scopes.core import actor
 from scopes.core.message import Message
 from scopes.util import keywords as k, Symbol
 
@@ -43,19 +42,6 @@ class Scope:
         return self
 
 def create_scope(env: Mailbox, cat=(k.csys, k.c00), **kw) -> Scope:
-    return Scope(environ=env, categ=cat, **kw)
+    scope = Scope(environ=env, categ=cat, **kw)
-
+    return scope.set_proc()
-def neuron(scope: Scope) -> Mailbox:
-    async def process(msg: Message) -> actor.Behavior | None:
-        nonlocal scope
-        new_scope = await scope.proc(scope, msg)
-        if new_scope is not None:
-            scope = new_scope
-        return process
-    return actor.create(process)
-
-def create_zero(env: Mailbox) -> Mailbox:
-    scope = create_scope(env)
-    zero = neuron(scope)
-    return zero
 

scopes/core/environ.py

@@ -8,9 +8,7 @@ from scopes.util import keywords as k
 
 async def proc_env(scope, msg):
     await scope.environ.put(msg)
-    #return scope
 
 def create(meta_env):
-    scope = core.create_scope(meta_env, (k.env, k.c00), program=lambda x: proc_env)
+    return core.create_scope(meta_env, (k.env, k.c00), program=lambda x: proc_env)
-    return core.neuron(scope)
 

tests/test_core.py

@@ -6,41 +6,37 @@ import asyncio
 import pytest
 
 from scopes import core
-from scopes.core import actor, environ
+from scopes.core import actor, environ, message
-from scopes.core.message import Message
 from scopes.util import keywords as k
 
-@pytest.fixture
+collector = []
-def collector():
+
-    return []
+def show(msg):
+    collector.append(msg)
 
 
-def show(msg, coll):
+async def handle_basic(msg):
-    coll.append(msg)
-
-def handle_basic(coll):
-    async def handle(msg):
     match msg:
-          case k.show: show(msg, coll)
+        case k.show: show(msg)
-          case k.switch: return handle_alt(coll)
+        case k.switch: return handle_alt
-          case _: show(msg, coll)
+        case _: show(msg)
-    return handle
 
-def handle_alt(coll):
+async def handle_alt(msg):
-    async def handle(msg):
     match msg:
-          case k.show: show('switched', coll)
+        case k.show: show('switched')
-          case _: await asyncio.sleep(0.01); show(msg, coll)
+        case _: await asyncio.sleep(0.01); show(msg)
-    return handle
 
 
 @pytest.mark.anyio
-async def test_actor(collector):
+async def test_actor():
     async with asyncio.TaskGroup() as group:
-        q1 = actor.create(handle_basic(collector), group)
+        q1 = actor.create(handle_basic, group)
-        q2 = actor.create(handle_basic(collector), group)
+        q2 = actor.create(handle_basic, group)
-        msgs = [Message(k.test, k.hello), k.show, k.switch, k.show, "actor 1: Goodbye"]
+        await q1.put(message.Message(k.test, k.hello))
-        await asyncio.gather(*[q1.put(m) for m in msgs])
+        await q1.put(k.show)
+        await q1.put(k.switch)
+        await q1.put(k.show)
+        await q1.put("actor 1: Goodbye")
         await q2.put("actor 2")
         await q2.put(k.show)
         await q1.put(k.quit)
@@ -51,7 +47,7 @@ async def test_actor(collector):
 
 
 def test_message():
-    msg = Message(k.test, k.data, 'person', '4711', 
+    msg = message.Message(k.test, k.data, 'person', '4711', 
                   data=dict(firstName='Bob', lastName='Miller'))
     assert msg.head['class'] is k.person
     assert msg.addr() == (k.test, k.person, '4711')
@@ -59,22 +55,19 @@ def test_message():
 
 
 @pytest.fixture
-async def meta_env(collector):
+def coll():
+    return []
+
+@pytest.fixture
+async def meta_env(coll):
     async def collect(msg):
-        collector.append(msg)
+        coll.append(msg)
     return actor.create(collect)
 
 @pytest.mark.anyio
-async def test_core(meta_env, collector):
+async def test_core(meta_env, coll):
-    env = environ.create(meta_env)
+    env_scope = environ.create(meta_env)
-    await env.put(Message(k.env, k.hello))
+    assert env_scope.value == 0
+    #print(meta_env)
     await asyncio.sleep(0.01)
-    assert len(collector) == 1
-    assert collector[0].domain is k.env
-    zero = core.create_zero(env)
-    await zero.put(Message(k.csys, k.hello))
-    await asyncio.sleep(0.01)
-    assert len(collector) == 2
-    assert collector[1].domain is k.csys
-    #print(collector)