apps/csys/lib/application.ex

@@ -11,9 +11,11 @@ defmodule Scopes.CSys.Application do
   def start(type, args) do
     IO.puts("Hello CSys")
     Logger.info(Util.show [type, args])
+    # input_neurons = Environ.create_input
+    IO.inspect Scopes.CSys.Server.Endpoint.child_spec(input: %{[:csys, :s01] => "dummy"})
     children = [
-      Scopes.Core.Environ,
+      #Scopes.CSys.Server.Endpoint
-      Scopes.CSys.Server.Endpoint
+      {Scopes.CSys.Server.Endpoint, input: %{[:csys, :s01] => "dummy"}}
     ]
     opts = [strategy: :one_for_one, name: Scopes.CSys.Supervisor]
     Supervisor.start_link(children, opts)

apps/csys/lib/server/endpoint.ex

@@ -1,6 +1,12 @@
 defmodule Scopes.CSys.Server.Endpoint do
   use Phoenix.Endpoint, otp_app: :scopes_csys
 
+  def init(arg) do
+    IO.inspect(arg)
+    IO.inspect(Process.get())
+    :ignore
+  end
+
   plug Plug.Static,
     at: "/",
     from: :scopes_csys,
@@ -16,4 +22,5 @@ defmodule Scopes.CSys.Server.Endpoint do
     json_decoder: Phoenix.json_library()
 
   plug Scopes.CSys.Server.Router
+    #input_neurons: @input
 end

lib/application.ex

@@ -12,7 +12,7 @@ defmodule Scopes.Application do
 
   @impl true
   def start(type, args) do
-    IO.puts("Hello Scopes!")
+    IO.puts("Hello World")
     Logger.info(Util.show [type, args])
     children = [
       #Scopes.Web.Server.Telemetry,
@@ -28,7 +28,7 @@ defmodule Scopes.Application do
 
     # See https://hexdocs.pm/elixir/Supervisor.html
     # for other strategies and supported options
-    opts = [strategy: :one_for_one, name: Scopes.Supervisor]
+    opts = [strategy: :one_for_one, name: ScopesApi.Supervisor]
     Supervisor.start_link(children, opts)
   end
 

lib/core/environ.ex

@@ -1,5 +1,4 @@
 defmodule Scopes.Core.Environ do
-  @cell_registry __MODULE__.Cells
 
   alias Scopes.Core
   alias Scopes.Core.Shape
@@ -8,17 +7,6 @@ defmodule Scopes.Core.Environ do
     defstruct [cells: %{}, init_seq: []]
   end
 
-  def child_spec(opts) do
-    %{id: __MODULE__, 
-      start: {__MODULE__, :start_link, opts}}
-  end
-
-  def start_link() do
-    Registry.start_link(keys: :unique, name: @cell_registry)
-  end
-
-  def cells(), do: @cell_registry
-
   def setup({state, proc}, init_seq, proc_env \\ &proc_env/2) do
     env_scope = {%State{init_seq: init_seq}, proc_env, [], self()}
     env = Core.neuron(env_scope)
@@ -42,7 +30,6 @@ defmodule Scopes.Core.Environ do
     addr = data[:addr]
     cells = if addr do
       [dom, cat, item] = addr
-      # update (or create and register) proxy cell
       Map.update(state.cells, {dom, cat}, %{item => new}, 
         fn x -> Map.put(x, item, new) end)
     else

lib/core/program.ex

@@ -62,7 +62,6 @@ defmodule Scopes.Core.Program do
         [:csys, :connect | _rest] -> Core.connect(msg, scope)
         [:csys, :create, :succ | _rest] -> create_succ(msg, scope)
         [:csys, :create, :pred | _rest] -> create_pred(msg, scope)
-        [:csys, :create | _rest] -> create(msg, scope)
         #[:csys, :next | _rest] -> next(msg, scope)
         _ -> Core.forward(msg, scope) || Core.notify(msg, scope)
       end
@@ -104,16 +103,6 @@ defmodule Scopes.Core.Program do
     Core.send_message(new, ~w(csys connect)a, Map.put(data, :target, self()))
   end
 
-  def create(msg, scope) do
-    new = Core.create(msg, restart(scope))
-    data = Shape.data(msg)
-    case data[:dir] do
-      :succ -> Core.send_message(self(), ~w(csys connect)a, Map.put(data, :target, new))
-      :pred -> Core.send_message(new, ~w(csys connect)a, Map.put(data, :target, self()))
-      _ -> nil
-    end
-  end
-
   # synapse operations
 
   def multiply(n) do
@@ -139,23 +128,34 @@ defmodule Scopes.Core.Program do
     one = [:csys, :s01, "1-0"]
     two = [:csys, :c00, "1-1"]
     three = [:csys, :s01, "1-1"]
-    [ 
+    [
-      &Environ.send_message(&1, zero, ~w(csys create pred)a, 
+      fn state -> 
-        %{op: [Core.data_only(), negate()], addr: one}),
+        Environ.send_message(state, zero, ~w(csys create pred)a, 
-      &Environ.send_message(&1, one, ~w(csys create succ)a, 
+         %{op: [Core.data_only(), negate()], addr: one})
-        %{op: Core.data_only(), addr: two}),
+     end,
-      &Environ.send_message(&1, two, ~w(csys create pred)a, %{addr: three}),
+     fn state -> 
-      &Environ.connect(&1, three, zero)
+       Environ.send_message(state, one, ~w(csys create succ)a, 
+         %{op: Core.data_only(), addr: two}) 
+     end,
+      fn state -> 
+        Environ.send_message(state, two, ~w(csys create pred)a, %{addr: three}) 
+      end,
+      fn state -> Environ.connect(state, three, zero) end
     ]
   end
 
   def init_recursive_1() do 
     zero = [:csys, :c00, "0-0"]
     [
-      &Environ.send_message(&1, zero, ~w(csys create succ)a, %{}),
+      fn state -> 
-      &Environ.send_message(&1, zero, ~w(csys create pred)a,
+        Environ.connect(state, zero, zero, negate())
-          %{addr: [:csys, :s01, "1-1"]}),
+        Environ.send_message(state, zero, ~w(csys create succ)a, 
-      &Environ.connect(&1, zero, zero, negate())
+          %{addr: [:csys, :e01, "1-1"]})
+      end,
+      fn state ->
+        Environ.send_message(state, zero, ~w(csys create pred)a,
+          %{addr: [:csys, :s01, "1-1"]})
+      end
     ]
   end
 end

test/core/core_test.exs

@@ -17,7 +17,6 @@ defmodule Scopes.CoreTest do
 
   describe "core-basic:" do
     test "minimal-b1" do
-      Environ.start_link()
       env = Environ.setup(Program.prepare_basic(), Program.init_seq_b1())
       Process.sleep(50)
       Environ.forward_value(env, [:csys, :c00, "0-0"], 0)
@@ -32,7 +31,6 @@ defmodule Scopes.CoreTest do
     end
 
     test "recursive-1" do
-      Environ.start_link()
       env = Environ.setup(Program.prepare_basic(), Program.init_recursive_1())
       Process.sleep(50)
       Environ.forward_value(env, [:csys, :s01, "1-1"], 42)