csys: supply synapse op via data field on neuron creation message

lib/csys/csys.ex

@@ -35,9 +35,9 @@ defmodule Scopes.CSys do
   
   def noop(msg), do: msg
 
-  # sending shortcuts
+  # `send` shortcuts
 
-  def send_message(rcvr, head, data) do
+  def send_message(rcvr, head, data \\ %{}) do
     Actor.send(rcvr, Shape.create(head, data: data))
   end
 

lib/csys/program.ex

@@ -3,6 +3,7 @@ defmodule Scopes.CSys.Program do
     neuron: 1, update_neuron: 1, synapse: 3
   ]
   alias Scopes.CSys
+  alias Scopes.Shape
 
   defmodule State do
     defstruct [:value, :stage, :prog]
@@ -55,8 +56,8 @@ defmodule Scopes.CSys.Program do
 
   def basic(msg = {head, _info}, scope) do
     case head do
-      [:csys, :create, :pred | _rest] -> create_pred(scope)
-      [:csys, :create, :succ | _rest] -> create_succ(scope)
+      [:csys, :create, :pred | _rest] -> create_pred(msg, scope)
+      [:csys, :create, :succ | _rest] -> create_succ(msg, scope)
       #[:csys, :next | _rest] -> next(scope, meta)
       #[:csys, :data | rest] -> process_data(rest, Shape.data(msg), scope)
       #[:csys, action | rest] -> transition(action, scope)
@@ -81,17 +82,19 @@ defmodule Scopes.CSys.Program do
 # 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(scope = {state, proc, _syns, env}) do
-    syn = synapse(self(), &CSys.noop/1, 0)
+  def create_pred(msg, scope = {state, proc, _syns, env}) do
+    op = Shape.data(msg)[:op] || &CSys.noop/1
+    syn = synapse(self(), op, 0)
     new = neuron(restart({state, proc, [syn], env}))
     CSys.notify({:created, new}, scope)
     update_neuron(restart(scope))
   end
 
-  def create_succ (scope = {state, proc, syns, env}) do
+  def create_succ(msg, scope = {state, proc, syns, env}) do
+    op = Shape.data(msg)[:op] || &CSys.noop/1
     new = neuron(restart({state, proc, [], env}))
     CSys.notify({:created, new}, scope)
-    syn = synapse(new, &CSys.noop/1, 0)
+    syn = synapse(new, op, 0)
     update_neuron(restart({state, proc, [syn | syns], env}))
   end
 end

test/csys_test.exs

@@ -2,7 +2,6 @@ defmodule Scopes.CSysTest do
   use ExUnit.Case, async: true
   @moduletag timeout: 5000
 
-  alias Scopes.Core.Actor
   alias Scopes.CSys
   alias Scopes.CSys.Environ
   alias Scopes.CSys.Program
@@ -17,20 +16,26 @@ defmodule Scopes.CSysTest do
     Shape.data(receive_select(head))
   end
 
+  def neg_only(msg) do
+    val = Shape.data(msg)[:value]
+    if val && val < 0 do
+      msg
+    end
+  end
+
   describe "basic:" do
     test "minimal-neural-net" do
       zero = Environ.setup(Program.prepare_basic())
-      #Actor.send(zero, "Hello Zero!")
       CSys.send_value(zero, "Hello Zero!")
       assert "Hello Zero!" = receive_data().value
-      Actor.send(zero, {[:csys, :create, :pred], nil})
-      #Actor.send(zero, {[:csys, :create, :pred], data: %{op: &neg_only/1})
+      #CSys.send_message(zero, [:csys, :create, :pred])
+      CSys.send_message(zero, [:csys, :create, :pred], %{op: &neg_only/1})
       assert_receive {:created, new1}
-      Actor.send(new1, {[:csys, :create, :succ], nil})
+      CSys.send_message(new1, [:csys, :create, :succ])
       assert_receive {:created, _new2}
-      Actor.send(new1, "Hello New1!")
-      assert_receive "Hello New1!"
-      assert_receive "Hello New1!"
+      CSys.send_value(new1, "Hello New1!")
+      assert "Hello New1!" = receive_data().value
+      #assert "Hello New1!" = receive_data().value
       Process.sleep(50)
       # Actor.stop(zero)
       refute_received msg, "unhandled message(s): #{inspect(msg)}"