csys clean-up: remove obsolete code, setup: use proc, other minor improvements

lib/csys/csys.ex

@@ -7,7 +7,6 @@ defmodule Scopes.CSys do
   def neuron(scope) do
     Logger.info([scope: inspect(scope)])
     Actor.create(fn msg -> process(msg, scope) end)
-    # Environ.register(env, ac, ...)
   end
 
   def update_neuron(scope) do

lib/csys/environ.ex

@@ -3,48 +3,12 @@ defmodule Scopes.CSys.Environ do
 
   alias Scopes.CSys
 
-  def setup(prog) do
+  def setup(proc) do
-    env = CSys.neuron({[], &proc/2, [], self()})
+    env = CSys.neuron({[], &proc_env/2, [], self()})
-    proc = prog[:initial]
     CSys.neuron({[], proc, [], env})
-    #CSys.neuron({[], proc, [], self()})
   end
 
-  def proc(msg, scope) do
+  def proc_env(msg, scope) do
     send(CSys.env(scope), msg)
   end
-
-# legacy /obsolete: Agent-based environ with program registry
-
-  def create(parent, progs \\ %{}) do
-    {:ok, env} = Agent.start_link( fn -> {parent, progs} end, name: __MODULE__)
-    env
-  end
-
-  def get_prog(env, name) do
-    Agent.get(env, fn {_parent, progs} ->
-      progs[name]
-    end)
-  end
-
-  def get_stage(env, prog, stage) do
-    Agent.get(env, fn {_parent, progs} ->
-      stages = progs[prog]
-      stages[stage] || stages[:default]
-    end)
-  end
-
-  def put_prog(env, name, prog) do
-    Agent.update(env, fn {parent, progs} ->
-      {parent, Map.put(progs, name, prog)}
-    end)
-  end
-
-  def notify(env, msg) do
-    Agent.cast(env, fn state -> 
-      {parent, _progs} = state
-      send(parent, msg)
-      state
-    end) 
-  end
 end

lib/csys/program.ex

@@ -9,10 +9,11 @@ defmodule Scopes.CSys.Program do
   # programs
 
   def basic_prog() do
-    %{default: &basic_active/2,
+    default = &basic_active/2
-      initial: &basic_active/2,
+    %{default: default,
-      active: &basic_active/2,
+      initial: default,
-      retired: &basic_active/2
+      active: default,
+      retired: default
     }
   end
 
@@ -22,6 +23,8 @@ defmodule Scopes.CSys.Program do
     case head do
       [:csys, :create, :pred | _rest] -> create_pred(scope)
       [:csys, :create, :succ | _rest] -> create_succ(scope)
+      #[:csys, :next | _rest] -> CSys.update_neuron({state, &basic_active/2, syns, env})
+      #[:csys, :next | _rest] -> next(:active, scope)
       _ -> forward(msg, scope) || notify(msg, scope)
     end
   end
@@ -48,7 +51,6 @@ defmodule Scopes.CSys.Program do
 
   def create_pred(scope = {_state, proc, _syns, env}) do
     syn = synapse(self(), &Function.identity/1, 0)
-    #neuron({[], Environ.get_stage(env, :basic, :initial), [syn], env})
     new = neuron({[], proc, [syn], env})
     notify({:created, new}, scope)
   end

test/csys_test.exs

@@ -8,18 +8,18 @@ defmodule Scopes.CSysTest do
   alias Scopes.CSys.Program
   alias Scopes.Shape
 
-  def receive_with(head) do
+  def receive_select(head) do
     assert_receive {^head, info}
     {head, info}
   end
 
-  def receive_data() do
+  def receive_data(head \\ [:csys, :data]) do
-    Shape.data(receive_with([:csys, :data]))
+    Shape.data(receive_select(head))
   end
 
   describe "basic:" do
     test "minimal-neural-net" do
-      zero = Environ.setup(Program.basic_prog())
+      zero = Environ.setup(Program.basic_prog()[:initial])
       #Actor.send(zero, "Hello Zero!")
       CSys.send_value(zero, "Hello Zero!")
       assert "Hello Zero!" = receive_data().value