csys: add connect_succ action, + test

lib/csys/csys.ex

@@ -5,7 +5,7 @@ defmodule Scopes.CSys do
   alias Scopes.Shape
 
   def neuron(scope) do
-    Logger.info([scope: inspect(scope)])
+    #Logger.info([scope: inspect(scope)])
     Actor.create(fn msg -> process(msg, scope) end)
   end
 
@@ -33,13 +33,10 @@ defmodule Scopes.CSys do
 
   # synapse operations
   
-  def noop(msg), do: msg
+  def noop(), do: fn msg -> msg end
 
   def filter_head(pat) do
-    fn msg -> 
+    fn msg -> if List.starts_with?(Shape.head(msg), pat), do: msg end
-      head = Shape.head(msg)
-      if List.starts_with?(head, pat), do: msg
-    end
   end
 
   def data_only(), do: filter_head([:csys, :data])
@@ -47,6 +44,7 @@ defmodule Scopes.CSys do
   # `send` shortcuts
 
   def send_message(rcvr, head, data \\ %{}) do
+    Logger.info([rcvr: inspect(rcvr), head: inspect(head), data: inspect(data)])
     Actor.send(rcvr, Shape.create(head, data: data))
   end
 

lib/csys/program.ex

@@ -56,8 +56,9 @@ defmodule Scopes.CSys.Program do
 
   def basic(msg = {head, _info}, scope) do
     case head do
-      [:csys, :create, :pred | _rest] -> create_pred(msg, scope)
+      [:csys, :connect, :succ | _rest] -> connect_succ(msg, scope)
       [:csys, :create, :succ | _rest] -> create_succ(msg, scope)
+      [:csys, :create, :pred | _rest] -> create_pred(msg, scope)
       #[:csys, :next | _rest] -> next(scope, meta)
       #[:csys, :data | rest] -> process_data(rest, Shape.data(msg), scope)
       #[:csys, action | rest] -> transition(action, scope)
@@ -78,23 +79,31 @@ defmodule Scopes.CSys.Program do
 
 # step functions
 
-# create_... steps
+# connect, create_... steps
 # todo: provide parameters for initial state, proc / stage, op,
 #       depending on state and stage (proc) of self, as well as message, env, ...
 
-  def create_pred(msg, scope = {state, proc, _syns, env}) do
+  def connect_succ(msg, {state, proc, syns, env}) do
-    op = Shape.data(msg)[:op] || &CSys.noop/1
+    data = Shape.data(msg)
-    syn = synapse(self(), op, 0)
+    op = data[:op] || CSys.noop()
-    new = neuron(restart({state, proc, [syn], env}))
+    succ = data[:succ]
-    CSys.notify({:created, new}, scope)
+    syn = synapse(succ, op, 0)
-    update_neuron(restart(scope))
+    update_neuron({state, proc, [syn | syns], env})
   end
 
   def create_succ(msg, scope = {state, proc, syns, env}) do
-    op = Shape.data(msg)[:op] || &CSys.noop/1
+    op = Shape.data(msg)[:op] || CSys.noop()
     new = neuron(restart({state, proc, [], env}))
     CSys.notify({:created, new}, scope)
     syn = synapse(new, op, 0)
     update_neuron(restart({state, proc, [syn | syns], env}))
   end
+
+  def create_pred(msg, scope = {state, proc, _syns, env}) do
+    op = Shape.data(msg)[:op] || CSys.noop()
+    syn = synapse(self(), op, 0)
+    new = neuron(restart({state, proc, [syn], env}))
+    CSys.notify({:created, new}, scope)
+    update_neuron(restart(scope))
+  end
 end

test/csys_test.exs

@@ -16,8 +16,8 @@ defmodule Scopes.CSysTest do
     Shape.data(receive_select(head))
   end
 
-  def neg_only(msg) do
+  def neg_only() do
-    if Shape.data(msg)[:value] < 0, do: msg
+    fn msg -> if Shape.data(msg)[:value] < 0, do: msg end
   end
 
   describe "basic:" do
@@ -25,13 +25,20 @@ defmodule Scopes.CSysTest do
       zero = Environ.setup(Program.prepare_basic())
       CSys.send_value(zero, "Hello Zero!")
       assert "Hello Zero!" = receive_data().value
-      CSys.send_message(zero, [:csys, :create, :pred], %{op: &neg_only/1})
+      CSys.send_message(zero, [:csys, :create, :pred], %{op: neg_only()})
+      # new1 = receive_data([:csys :created]).neuron
       assert_receive {:created, new1}
       CSys.send_message(new1, [:csys, :create, :succ], %{op: CSys.data_only()})
-      assert_receive {:created, _new2}
+      assert_receive {:created, new2}
       CSys.send_value(new1, "Hello New1!")
       assert "Hello New1!" = receive_data().value
-      #assert "Hello New1!" = receive_data().value
+      CSys.send_message(new2, [:csys, :create, :pred])
+      assert_receive {:created, new3}
+      CSys.send_message(new3, [:csys, :connect, :succ], %{succ: zero})
+      Process.sleep(1)
+      CSys.send_value(new3, "Hello New3!")
+      assert "Hello New3!" = receive_data().value
+      assert "Hello New3!" = receive_data().value
       Process.sleep(50)
       refute_received msg, "unhandled message(s): #{inspect(msg)}"
     end