csys: set proc depending on current stage, restart scopes upon neuron creation

lib/csys/program.ex

@@ -9,10 +9,20 @@ defmodule Scopes.CSys.Program do
     defstruct [:value, :stage, :prog]
   end
 
-  def prepare(prog) do
+  def prepare(prog, value \\ []) do
-    {%State{value: 0, stage: :initial, prog: prog}, elem(prog, 0)[:initial]}
+    state = %State{value: value, stage: :initial, prog: prog}
+    {state, get_proc(state)}
   end
 
+  def get_proc(stages, stage) do
+    stages[stage] || stages[:default]
+  end
+
+  def get_proc(state) do
+    get_proc(elem(state.prog, 0), state.stage)
+  end
+
+
   # basic program
 
   def basic_prog() do
@@ -31,8 +41,8 @@ defmodule Scopes.CSys.Program do
     {stages, transitions}
   end
 
-  def prepare_basic() do
+  def prepare_basic(value \\ []) do
-    prepare(basic_prog())
+    prepare(basic_prog(), value)
   end
 
   # basic processors
@@ -60,7 +70,7 @@ defmodule Scopes.CSys.Program do
     forward(msg, scope) || notify(msg, scope)
   end
 
-# processor steps
+# processor steps, helper functions
 
   def notify(msg, scope) do
     Actor.send(env(scope), msg)
@@ -70,22 +80,28 @@ defmodule Scopes.CSys.Program do
     Enum.reduce(syns(scope), false, fn s, _acc -> s.(msg); true end)
   end
 
+  def restart({state, _proc, syns, env}) do
+    nstate = %{state | stage: :initial}
+    {nstate, get_proc(nstate), syns, env}
+  end
+
 # step functions
 
 # 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(scope = {_state, proc, _syns, env}) do
+  def create_pred(scope = {state, proc, _syns, env}) do
     syn = synapse(self(), &Function.identity/1, 0)
-    new = neuron({[], proc, [syn], env})
+    new = neuron(restart({state, proc, [syn], env}))
     notify({:created, new}, scope)
+    update_neuron(restart(scope))
   end
 
   def create_succ (scope = {state, proc, syns, env}) do
-    new = neuron({[], proc, [], env})
+    new = neuron(restart({state, proc, [], env}))
-    syn = synapse(new, &Function.identity/1, 0)
-    update_neuron({state, proc, [syn | syns], env})
     notify({:created, new}, scope)
+    syn = synapse(new, &Function.identity/1, 0)
+    update_neuron(restart({state, proc, [syn | syns], env}))
   end
 end

test/csys_test.exs

@@ -24,7 +24,7 @@ defmodule Scopes.CSysTest do
       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})
+      #Actor.send(zero, {[:csys, :create, :pred], data: %{op: &neg_only/1})
       assert_receive {:created, new1}
       Actor.send(new1, {[:csys, :create, :succ], nil})
       assert_receive {:created, _new2}