Regarding something else.

For later. Good topic for a post. Haven't made one in a few days.

Logical, function programming is really very elegant. Would be nice to make a concurrent implementation with something like Erlang under the hood. Like reimplement flat concurrent prolog with a few well known features also included. A combination is more than the sum of its parts.

Here's how we can think about Erlang. The following is theoretical discussion. Of primarily academic interest. Let's see if a really concise, natural language explanation is possible.

It simply already does well what we would want at the lowest level. We want the threads and concurrency and message passing to be real and primary.

Once we have basic actor agents, we build operations like the following. Write simple functions. List in named libraries for convenience. A.B here means A selected from B as usual. We can define actor agents like in flat concurrent prolog. Define some initial inputs, if any, Loads, define some Exceptions, heuristics that run on Loads, input messages, and prune the list of Operations, which are run on Loads until a valid output or time out or crash and restart or Operations all fail to produce a valid output in some order. Operations are defined as procedures, function in the base language. There may be Notes, for Petri net type marks or Holland tags, as actors agents can be treated as wholes as messages, and these implement, anyway, Hewitt actor rules, in that notes tell how to treat future messages. Valid outputs of Operations can be stored for a while as valid Inputs to other Destinations, which are stored addresses. Sent out as messages perhaps with some delay. Like: spawn(ForAll(A)(ForAll(B)(neuron(message(<>,<>,r).RandomsLibrary, f_initial=1/2).NeuronsLibrary).Operations).Operations).
Here: neuron would create a new actor agent for the pair indicated. Not necessary that pairs used. Tuples or more complex structure like other nets can be considered, if multiarrows allowed.

Different actor agents have different operations and a neuron in a net can be a procedure that removes a load in A, a message it would operate on later, for example received but in queue, but operating on something else first, and instead sends that to B. Which has a different set of operations. Logic by elimination. This redirect may be with a frequency. Initially set at 1/2. Mundane learning by tweaking a coefficient in case output deviates from a developer supplied or network generated output is an operation among others inside actor agents of the net. Each does logic. And a log of which operations succeeded and which failed on which load reveals that logic. That can be a message sent to actors in the net. Meanwhile they tweak as net runs on messages sent to it as experience and performs reasoning and where reasoning fails changes reasoning, and as some messages document its reasoning failures it can change its reasoning based on its own descriptions of its own reasoning. Because testing different operations and characterizing what branches give a valid output which don't, is elimination logic, means to ordinary formal logic. Experience and logic are mixed. Neural nets can do logical reasoning, which is not always correct, but depends on experience, so nonmonotonic in the sense of McCarthy. Just usual logical, functional programming where well known actors or fcp agents are first class objects and the primary units.

This is how things like flat concurrent prolog operate. Makes for very short code. But challenging to predict what outputs, if any, code will produce. Analysis still required to model make good predictions about whether such a net will solve or not a particular problem. Open problem in science.