csys: + environ for storing programs and parent, with get and notify functions

.formatter.exs

@@ -1,4 +1,5 @@
 # Used by "mix format"
 [
-  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  # inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs"] # avoid unintentional formatting of code
 ]

lib/csys/csys.ex

@@ -1,5 +1,6 @@
 defmodule Scopes.CSys do
   alias Scopes.Core.Actor
+  alias Scopes.CSys.Environ
 
   def neuron(scope) do
     Actor.create(fn msg -> process(msg, scope) end)
@@ -15,23 +16,23 @@ defmodule Scopes.CSys do
     proc(scope).(msg, scope)
   end
 
-  def echo(msg, scope) do
-    send(env(scope), msg)
+  def notify(msg, scope) do
+    Environ.notify(env(scope), msg)
   end
 
   def forward(msg, scope) do
-    Enum.reduce(syns(scope), false, fn s, _acc -> s.(msg) end)
+    Enum.reduce(syns(scope), false, fn s, _acc -> s.(msg); true end)
   end
 
   def std_proc({:parent}, scope) do
+    env = env(scope)
     syn = synapse(self(), &Function.identity/1)
-    new = neuron({[], [&std_proc/2], [syn], env(scope)})
-    # send(env(scope), {:created, new})
-    echo({:created, new}, scope)
+    new = neuron({[], Environ.get_prog(env, :basic), [syn], env})
+    notify({:created, new}, scope)
   end
 
   def std_proc(msg, scope) do
-    unless forward(msg, scope), do: echo(msg, scope)
+    unless forward(msg, scope), do: notify(msg, scope)
   end
 
   # helper functions

lib/csys/environ.ex

@@ -0,0 +1,23 @@
+defmodule Scopes.CSys.Environ do
+  use Agent
+
+  def create(parent, progs) do
+    {:ok, env} = Agent.start_link(
+      fn -> %{parent: parent, programs: progs} end, 
+      name: __MODULE__)
+    env
+  end
+
+  def get_prog(env, name) do
+    Agent.get(env, fn state ->
+      state.programs[name]
+    end)
+  end
+
+  def notify(env, msg) do
+    Agent.cast(env, fn state -> 
+      send(state.parent, msg)
+      state
+    end) 
+  end
+end

test/csys_test.exs

@@ -4,10 +4,17 @@ defmodule Scopes.CSysTest do
 
   alias Scopes.Core.Actor
   alias Scopes.CSys
+  alias Scopes.CSys.Environ
+
+  def basic_prog() do
+    %{basic: [&CSys.std_proc/2]}
+  end
 
   describe "basic:" do
     test "minimal-neural-net" do
-      zero = CSys.neuron({[], [&CSys.std_proc/2], [], self()})
+      env = Environ.create(self(), basic_prog()) # or: Programs.basic()
+      std_program = Environ.get_prog(env, :basic)
+      zero = CSys.neuron({[], std_program, [], env})
       Actor.send(zero, "Hello Zero!")
       assert_receive "Hello Zero!"
       Actor.send(zero, {:parent})