csys: basically working: delegating tasks from app to env, getting neurons via address

lib/csys/environ.ex

@@ -15,12 +15,18 @@ defmodule Scopes.CSys.Environ do
     env
   end
 
-  def proc_env(msg, scope) do
+  def proc_env(msg, scope = {state, _proc, _syns, env}) do
     case Shape.head(msg) do
-      [:csys, :created | _rest] -> process_creation(msg, scope)
-      _ -> nil
+      {:exec, func} -> func.(state)
+      [:csys, :created | _rest] -> 
+        process_creation(msg, scope)
+        send(env, msg)
+      [dom, :for, cat, item] ->
+        #IO.inspect(CSys.state(scope).cells)
+        cell = get_in(state.cells, [{dom, cat}, item])
+        CSys.send_message(cell, [dom, :data], Shape.data(msg))
+      _ -> send(env, msg) # forward message to application
     end
-    send(CSys.env(scope), msg)
   end
 
   def process_creation(msg, {state, proc, syns, env}) do
@@ -40,7 +46,23 @@ defmodule Scopes.CSys.Environ do
     CSys.update({state1, proc, syns, env})
     if step do
       Process.sleep(1)
-      step.(env, state1)
+      step.(state1)
     end
   end
+
+  def send_message(state, [dom, cat, item], head, data) do
+    cell = get_in(state.cells, [{dom, cat}, item])
+    CSys.send_message(cell, head, data)
+  end
+
+  # delegating tasks to env
+
+  def delegate(env, func) do
+    CSys.send_message(env, {:exec, func})
+  end
+
+  def forward_value(env, addr, value) do
+    delegate(env, &send_message(&1, addr, ~w(csys data)a, %{value: value}))
+    #CSys.send_message(env, [dom, :for, cat, item], %{value: value})
+  end
 end

lib/csys/program.ex

@@ -135,17 +135,17 @@ defmodule Scopes.CSys.Program do
   # demo init sequences
  
   def init_seq_b1() do [
-    fn _env, %Environ.State{neurons: [zero]} -> 
+    fn %Environ.State{neurons: [zero]} -> 
       CSys.send_message(zero, ~w(csys create pred)a, 
         %{op: [CSys.data_only(), negate()]}) 
     end,
-    fn _env, %Environ.State{neurons: [one | _ns]} -> 
+    fn %Environ.State{neurons: [one | _ns]} -> 
       CSys.send_message(one, ~w(csys create succ)a, %{op: CSys.data_only()}) 
     end,
-    fn _env, %Environ.State{neurons: [two | _ns]} -> 
+    fn %Environ.State{neurons: [two | _ns]} -> 
       CSys.send_message(two, ~w(csys create pred)a) 
     end,
-    fn _env, %Environ.State{neurons: [three | others]} ->
+    fn %Environ.State{neurons: [three | others]} ->
       zero = List.last(others)
       CSys.send_message(three, ~w(csys connect)a, %{target: zero})
     end
@@ -153,8 +153,10 @@ defmodule Scopes.CSys.Program do
   end
 
   def init_recursive_1() do [
-    fn _env, %Environ.State{neurons: [zero]} -> 
+    fn %Environ.State{neurons: [zero]} -> 
+      #zero = [:csys, :c00, {0, 0}]
       CSys.send_message(zero, ~w(csys connect)a, %{target: zero, op: negate()}) 
+      #Environ.send_message(state, zero, ~w(csys connect)a, %{target: zero, op: negate()})
       CSys.send_message(zero, ~w(csys create succ)a, %{addr: [:csys, :e01, {1, 1}]})
     end
   ]

test/csys_test.exs

@@ -36,11 +36,12 @@ defmodule Scopes.CSysTest do
     end
 
     test "recursive-1" do
-      _env = Environ.setup(Program.prepare_basic(), Program.init_recursive_1())
-      zero = receive_data(~w(csys created)a).new
+      env = Environ.setup(Program.prepare_basic(), Program.init_recursive_1())
+      _zero = receive_data(~w(csys created)a).new
       _eff = receive_data(~w(csys created)a).new
       Process.sleep(10)
-      CSys.send_value(zero, 42)
+      #CSys.send_value(zero, 42)
+      Environ.forward_value(env, [:csys, :c00, {0, 0}], 42)
       assert receive_data().value == 42
       refute_received msg, "unhandled message(s): #{inspect(msg)}"
     end