World: r3wp

*can

each node has a multitude of connectivity options.

and connect several other nodes (plugs) to any node, you can even 
label and separate your connections,

the actual data you transport through the connections (links) is 
arbitrary, and can change at each data change.

hmm ok

containers hold the input data, so you can put anything in them...

then the linked nodes, will link to those containers, or other nodes, 
and the processing of each node, will determine what is output from 
the node as source data for another node or as actual processed data.

for example, if i have a collection of nodes, each of them, relative 
to a string

all the strings form a rebol script

yes?

if i want  manage the insertion or the deletion of one line of my 
source

i have to create myself a nex node or delete it, exact ?

*new node

not nex

you create a new node, with the new line of text and link it AT the 
offset which you want , and then just ask the master node for its 
text, and it will give you the new output. (if that is what its processing 
does)

so:

node_a = "a string"      -->	\
				 | node_c.output = "a string of text"
node_b = "of text"        -->	/

is see

but if i insert a node between a and b, node c is not informed ?

if you then insert node_d after node_a:
node_a = "a string"      -->	\

node_d =" ... "             -->	 |  node_c.output = "a string ... 
of text"
node_b = "of text"        -->	/

its lazy... (unless you tell it not to be)

ok

so node_c KNOWS its not up to date but computes nothing unless you 
need its value.

good thing

and thus, even if you change any input node's values or link new 
stuff to node_c... none of that will actually call any processing, 
untill you ask for the content of  node_c

and now a more harder question

which is how I decoupled the refresh and the event handler of my 
graph editor.

if i insert a newline in the text of node_a

how can i split node_a in 2 nodes ?

is there a trick to  auto split a node foolowing a specific rule 
?

that management is up to you.  liquid is a core kernel.  its not 
a language-driven... on purpose.

ok

I could have waisted time on some kind of generic node manager, but 
even after a year of work, it would still be useless... cause nodes 
are about processing.

liquid is a hybrid of storage, association, synchronisation, dependencies, 
and some in between.  it does all of those things using the same 
core node, and allows you to build any kind of manager, or dependecy 
model over it.

since nodes actually are objects, its not some mysterious hidden 
thing you try to grasp by reverse thinking of cause effect.

another question ?

you actually have access to all core methods like link, cycle?,  
process, init, propagate, etc.

no problem  :-)

how can we manage bijective depedency ?

for example:

you mean two nodes which are symmetric but actually have different 
data?

yes

like  a node which has "one" and another which has 1

(the second actually being an integer)

well that is done using pipes.

we have to nodes A et B

when A is modified B is updated

all members of a pipes are equal owners of the same value.

when B is modified, A must be updated

yes... already part of the engine... and again... the magic is doing 
so with the same actual object class   :-)

godd