103 lines
2.4 KiB
Elixir
103 lines
2.4 KiB
Elixir
defmodule Scopes.Core do
|
|
alias Scopes.Core.Actor
|
|
alias Scopes.Core.Shape
|
|
alias Scopes.Util
|
|
|
|
require Logger
|
|
require Util
|
|
|
|
def neuron(scope) do
|
|
#Logger.info(Util.show [scope])
|
|
Actor.create(fn msg -> process(msg, scope) end)
|
|
end
|
|
|
|
def update(scope) do
|
|
Actor.become(self(), fn msg -> process(msg, scope) end)
|
|
end
|
|
|
|
def synapse(rcvr, op, delay \\ 0) do
|
|
op = is_list(op) && compose(op) || op
|
|
fn msg -> Actor.send(rcvr, op.(msg), delay) end
|
|
end
|
|
|
|
# message handlers / proc steps
|
|
|
|
def process(msg, scope) do
|
|
proc(scope).(msg, scope)
|
|
end
|
|
|
|
def notify(msg, scope) do
|
|
Logger.info(Util.show [msg])
|
|
Actor.send(env(scope), msg)
|
|
end
|
|
|
|
def forward(msg, scope) do
|
|
#for s <- syns(scope), reduce: 0, do: (acc -> s.(msg); acc + 1)
|
|
for s <- syns(scope), reduce: false, do: (_acc -> s.(msg))
|
|
#Enum.reduce(syns(scope), false, fn s, _acc -> s.(msg); true end)
|
|
end
|
|
|
|
def create(msg, scope = {state, proc, _syns, env}) do
|
|
new = neuron({state, proc, [], env})
|
|
notify_created(msg, new, scope)
|
|
new
|
|
end
|
|
|
|
def connect(msg, {state, proc, syns, env}) do
|
|
data = Shape.data(msg)
|
|
op = data[:op] || []
|
|
syn = synapse(data[:target], op, 0)
|
|
update({state, proc, [syn | syns], env})
|
|
end
|
|
|
|
# synapse operations
|
|
|
|
def filter_head(pat) do
|
|
fn msg -> if List.starts_with?(Shape.head(msg), pat), do: msg end
|
|
end
|
|
|
|
def filter_address(pat) do
|
|
fn msg ->
|
|
[dom, _act | rest] = Shape.head(msg)
|
|
if List.starts_with?([dom | rest], pat), do: msg
|
|
end
|
|
end
|
|
|
|
def data_only(dom \\ :csys), do: filter_head([dom, :data])
|
|
|
|
# send shortcuts
|
|
|
|
def send_message(rcvr, head, data \\ %{}) do
|
|
Logger.debug(Util.show [rcvr, head, data])
|
|
Actor.send(rcvr, Shape.create(head, data: data))
|
|
end
|
|
|
|
def send_value(rcvr, val, dom \\ :csys) do
|
|
send_message(rcvr, [dom, :data], %{value: val})
|
|
end
|
|
|
|
# notifications
|
|
|
|
def notify_created(msg, new, scope) do
|
|
[dom | _rest] = Shape.head(msg)
|
|
msg1 = Shape.create([dom, :created],
|
|
data: Map.merge(Shape.data(msg), %{old: self(), new: new}))
|
|
notify(msg1, scope)
|
|
end
|
|
|
|
# scope access shortcuts
|
|
|
|
def state(scope), do: elem(scope, 0)
|
|
def proc(scope), do: elem(scope, 1)
|
|
def syns(scope), do: elem(scope, 2)
|
|
def env(scope), do: elem(scope, 3)
|
|
|
|
# helpers
|
|
|
|
def compose(ops) do
|
|
&(for op <- ops, reduce: &1 do
|
|
nil -> nil
|
|
val -> op.(val)
|
|
end)
|
|
end
|
|
end
|