CSys.Environ: identify proc via program and stage id

config/config.exs

@@ -2,9 +2,8 @@
 
 import Config
 
-config :logger, :default_handler,
+config :logger, :default_formatter,
-  config: [
+    format: "$date $time [$level] $metadata $message\n",
-    file: ~c"log/scopes.log"
+    metadata: [:mfa]
-  ]
 
 import_config "#{config_env()}.exs"

config/dev.exs

@@ -0,0 +1,8 @@
+# scopes: development config file
+
+import Config
+
+config :logger, :default_handler, 
+  config: [
+    file: ~c"log/scopes_dev.log"
+  ]

config/prod.exs

@@ -0,0 +1,9 @@
+# scopes: production config file
+
+import Config
+
+config :logger, :default_handler, 
+  config: [
+    file: ~c"log/scopes.log"
+  ]
+

config/test.exs

@@ -2,7 +2,8 @@
 
 import Config
 
-config :logger, :default_handler,
+config :logger, :default_handler, 
+  level: :info,
   config: [
     file: ~c"test/log/scopes_test.log"
   ]

lib/csys/csys.ex

@@ -4,11 +4,14 @@ defmodule Scopes.CSys do
   alias Scopes.Core.Actor
 
   def neuron(scope) do
-    #Logger.info("create neuron, scope: #{inspect scope}")
+    Logger.info([scope: inspect(scope)])
-    Logger.info([info: "create neuron", scope: inspect(scope)])
     Actor.create(fn msg -> process(msg, scope) end)
   end
 
+  def update_neuron(scope) do
+    Actor.become(self(), fn msg -> process(msg, scope) end)
+  end
+
   def synapse(rcvr, op) do
     fn msg -> Actor.send(rcvr, op.(msg)) end
   end
@@ -19,10 +22,8 @@ defmodule Scopes.CSys do
 
   # helper functions
 
-  def proc(scope), do: hd(code(scope))
-
   def state(scope), do: elem(scope, 0)
-  def code(scope), do: elem(scope, 1)
+  def proc(scope), do: elem(scope, 1)
   def syns(scope), do: elem(scope, 2)
   def env(scope), do: elem(scope, 3)
 end

lib/csys/environ.ex

@@ -12,6 +12,12 @@ defmodule Scopes.CSys.Environ do
     end)
   end
 
+  def get_stage(env, prog, stage) do
+    Agent.get(env, fn {_parent, progs} ->
+      progs[prog][stage]
+    end)
+  end
+
   def put_prog(env, name, prog) do
     Agent.update(env, fn {parent, progs} ->
       {parent, Map.put(progs, name, prog)}

lib/csys/programs.ex

@@ -1,12 +1,14 @@
 defmodule Scopes.CSys.Programs do
   import Scopes.CSys
 
+  alias Scopes.CSys
   alias Scopes.CSys.Environ
 
   # programs
 
   def basic_prog() do
-    [&std_proc/2]
+    %{initial: &std_proc/2}
+    #&std_proc/2
   end
 
   # processors
@@ -22,10 +24,18 @@ defmodule Scopes.CSys.Programs do
   def std_proc({:parent}, scope) do
     env = env(scope)
     syn = synapse(self(), &Function.identity/1)
-    new = neuron({[], Environ.get_prog(env, :basic), [syn], env})
+    new = neuron({[], Environ.get_stage(env, :basic, :initial), [syn], env})
     notify({:created, new}, scope)
   end
 
+  #def std_proc({:activate}, {state, _proc, syns, env) do
+  def std_proc({:next}, {state, _proc, syns, env}) do
+    #proc = Environ.get_next_stage(env, :basic, :initial)
+    #proc = Environ.get_stage_for(env, :basic, :activate)
+    proc = Environ.get_stage(env, :basic, :active)
+    CSys.update_neuron({state, proc, syns, env})
+  end
+
   def std_proc(msg, scope) do
     unless forward(msg, scope), do: notify(msg, scope)
   end

test/csys_test.exs

@@ -11,8 +11,9 @@ defmodule Scopes.CSysTest do
     test "minimal-neural-net" do
       env = Environ.create(self())
       Environ.put_prog(env, :basic, Programs.basic_prog())
-      std_program = Environ.get_prog(env, :basic)
+      #proc = Environ.get_prog(env, :basic)
-      zero = CSys.neuron({[], std_program, [], env})
+      proc = Environ.get_stage(env, :basic, :initial)
+      zero = CSys.neuron({[], proc, [], env})
       Actor.send(zero, "Hello Zero!")
       assert_receive "Hello Zero!"
       Actor.send(zero, {:parent})