csys: improve creation of neurons: separate connect, standardized notification

lib/csys/csys.ex

@@ -41,7 +41,7 @@ defmodule Scopes.CSys do
 
   def data_only(), do: filter_head([:csys, :data])
 
-  # `send` shortcuts
+  # send shortcuts
 
   def send_message(rcvr, head, data \\ %{}) do
     Logger.info([rcvr: inspect(rcvr), head: inspect(head), data: inspect(data)])
@@ -52,6 +52,13 @@ defmodule Scopes.CSys do
     send_message(rcvr, [:csys, :data], %{value: val}) 
   end
 
+  # notifications
+
+  def notify_created(new, scope) do
+    msg = Shape.create([:csys, :created], data: %{old: self(), new: new})
+    notify(msg, scope)
+  end
+
   # scope access shortcuts
 
   def state(scope), do: elem(scope, 0)

lib/csys/program.ex

@@ -56,7 +56,7 @@ defmodule Scopes.CSys.Program do
 
   def basic(msg = {head, _info}, scope) do
     case head do
-      [:csys, :connect, :succ | _rest] -> connect_succ(msg, scope)
+      [:csys, :connect | _rest] -> connect(msg, scope)
       [:csys, :create, :succ | _rest] -> create_succ(msg, scope)
       [:csys, :create, :pred | _rest] -> create_pred(msg, scope)
       #[:csys, :next | _rest] -> next(scope, meta)
@@ -83,27 +83,29 @@ 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 connect_succ(msg, {state, proc, syns, env}) do
+  def connect(msg, {state, proc, syns, env}) do
     data = Shape.data(msg)
     op = data[:op] || CSys.noop()
-    succ = data[:succ]
+    target = data[:target]
-    syn = synapse(succ, op, 0)
+    syn = synapse(target, op, 0)
     update_neuron({state, proc, [syn | syns], env})
   end
 
-  def create_succ(msg, scope = {state, proc, syns, env}) do
+  def create(_msg, scope = {state, proc, _syns, env}) do
-    op = Shape.data(msg)[:op] || CSys.noop()
     new = neuron(restart({state, proc, [], env}))
-    CSys.notify({:created, new}, scope)
+    CSys.notify_created(new, scope)
-    syn = synapse(new, op, 0)
+    new
-    update_neuron(restart({state, proc, [syn | syns], env}))
   end
 
-  def create_pred(msg, scope = {state, proc, _syns, env}) do
+  def create_succ(msg, scope) do
-    op = Shape.data(msg)[:op] || CSys.noop()
+    new = create(msg, scope)
-    syn = synapse(self(), op, 0)
+    data = Shape.data(msg)
-    new = neuron(restart({state, proc, [syn], env}))
+    CSys.send_message(self(), [:csys, :connect], Map.put(data, :target, new))
-    CSys.notify({:created, new}, scope)
+  end
-    update_neuron(restart(scope))
+
+  def create_pred(msg, scope) do
+    new = create(msg, scope)
+    data = Shape.data(msg)
+    CSys.send_message(new, [:csys, :connect], Map.put(data, :target, self()))
   end
 end

test/csys_test.exs

@@ -26,15 +26,15 @@ defmodule Scopes.CSysTest do
       CSys.send_value(zero, "Hello Zero!")
       assert "Hello Zero!" = receive_data().value
       CSys.send_message(zero, [:csys, :create, :pred], %{op: neg_only()})
-      # new1 = receive_data([:csys :created]).neuron
+      new1 = receive_data([:csys, :created]).new
-      assert_receive {:created, new1}
       CSys.send_message(new1, [:csys, :create, :succ], %{op: CSys.data_only()})
-      assert_receive {:created, new2}
+      new2 = receive_data([:csys, :created]).new
+      Process.sleep(1)
       CSys.send_value(new1, "Hello New1!")
       assert "Hello New1!" = receive_data().value
       CSys.send_message(new2, [:csys, :create, :pred])
-      assert_receive {:created, new3}
+      new3 = receive_data([:csys, :created]).new
-      CSys.send_message(new3, [:csys, :connect, :succ], %{succ: zero})
+      CSys.send_message(new3, [:csys, :connect], %{target: zero})
       Process.sleep(1)
       CSys.send_value(new3, "Hello New3!")
       assert "Hello New3!" = receive_data().value