Reflection operator

[emil14]

Operator that accepts message of some form (the API must be designed) it that can (in some magic way) update the program structure. Possible messages are:

1. Replace the whole/part of network with new network
2. Update part of the network
3. Add new nodes to network

---

This could be used for HMR (think about how can we not loose the "state")

---

This means runtime (or at least that operator) must have some knowledge about component's level abstractions

Problem

Runtime doesn't know anything about components and their content (say network, subnodes, etc)

Should we support anything that envolves knoledge about compiler

---

Related to #154 #118 #36 and #90 #160 #159

[emil14]

Provide an API at executor level

1. executor can have new entity called e.g. patcher that can have interface like Path(build, upd) newBuild
2. we can somehow pass that API down to the operator so it can call executor to update the program

Problems

How to pass API down to operator?

It's not clear how to pass something from executor to an operator since operators have very limited API in the form of ctx, io -> err. Maybe the interface of the operators must be updates to something a little bit more complex.

How to update program?

---

I can see 2 directions for now:

1. "Replace" the whole program (build)
2. Update only the necessary part

Solution 2 sounds obviously better, but solution 1 is what matches with the interface above. Solution 2 in order to be implemented must involve update API for both network manager and effector

[emil14]

React-like update

Just a though - maybe it could be useful to look at react's virtual dom, how it compares diffs and updates only what's needed

[emil14]

Possible set of commands

things that you can possibly change in the program are:

- get/set new start port
- get ports, port (group) by path+name, by path+name+idx
- update ports
    - delete existing port
        - delete slot of array of array port
    - insert new ports
        - insert slot of array port
    - change buffer size of existing port/slot
    - rename existing port/slot
    - move port/slot (change its path)
- get the whole network
- get/delete connections from/to specific
    - node (by path)
    - port (group) (by path+name)
    - slot (by path+name+idx)
- insert connections from slot to slot
- update existing connection (by from-to)
    - change it's action/selector
- get effects
    - get all givers
        - get givers by node
        - get specific giver by port address 
    - get all operators
        - get specific operator by operator reference (pkg+name?)

UPD: I don't see a reason of introducing a "node" abstraction to implement all this

UPD2: We can use such API to update program while debugging

Insert operator problem

How to add new operator if a program is compiled and we not use pluigns?

[emil14]

Go's context?

All components receive ctx. One possible option would be to simply hide runtime's API inside context