move neuron processor function into scope as code = list of stages

lib/csys/csys.ex

@@ -1,8 +1,8 @@
 defmodule Scopes.CSys do
   alias Scopes.Core.Actor
 
-  def neuron(proc, scope) do
-    fn msg -> proc.(msg, scope) end
+  def neuron(scope) do
+    Actor.create(fn msg -> process(msg, scope) end)
   end
 
   def synapse(rcvr, op) do
@@ -11,21 +11,25 @@ defmodule Scopes.CSys do
 
   # predefined neuron processors
 
-  def echo(msg, {_state, _syns, env}) do
+  def process(msg, scope) do
+    hd(elem(scope, 1)).(msg, scope)
+  end
+
+  def echo(msg, {_state, _code, _syns, env}) do
     send(env, msg)
   end
 
-  def forward(msg, {_state, syns, _env}) do
-    for s <- syns, do: s.(msg)
+  def forward(msg, {_state, _code, syns, _env}) do
+    Enum.reduce(syns, false, fn s, _acc -> s.(msg); true end)
   end
 
-  def std_proc({:parent}, {_state, _syns, env}) do
+  def std_proc({:parent}, {_state, _code, _syns, env}) do
     syn = synapse(self(), &Function.identity/1)
-    new = Actor.create(neuron(&std_proc/2, {nil, [syn], env}))
+    new = neuron({[], [&std_proc/2], [syn], env})
     send(env, {:created, new})
   end
 
   def std_proc(msg, scope) do
-    if forward(msg, scope) === [], do: echo(msg, scope)
+    unless forward(msg, scope), do: echo(msg, scope)
   end
 end

test/csys_test.exs

@@ -7,14 +7,14 @@ defmodule Scopes.CSysTest do
 
   describe "basic:" do
     test "minimal-neural-net" do
-      zero = Actor.create(CSys.neuron(&CSys.std_proc/2, {nil, [], self()}))
+      zero = CSys.neuron({[], [&CSys.std_proc/2], [], self()})
       Actor.send(zero, "Hello Zero!")
       assert_receive "Hello Zero!"
       Actor.send(zero, {:parent})
       assert_receive {:created, new}
       Actor.send(new, "Hello New!")
       assert_receive "Hello New!"
-      #assert_receive "Hello New!"
+      # assert_receive "Hello New!"
       Process.sleep(50)
       # Actor.stop(zero)
       refute_received msg, "unhandled message(s): #{inspect(msg)}"