World: r3wp

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

goog, sorry

*good

and its all VERY stable.  I've already got a view engine running 
the exact thing you describe where a scroll bar updates a field and 
vice versa... although one is a decimal and the other a string.

the nice thing about the pipe engine is that you have bidirectional 
data filtering.  when you SET the data, your pipe can unify it to 
some internal value, which is considered the real value.

i think i could work an a new concept of rebol script editor with 
liquid

then each member (including the one you modified the pipe with ! 
:-)  can then again, clean it up for its own use.

with a draw engine

pipe^s are so cools ^^

HAHAHA why do you think I have been designing liquid for the last 
4 years (and actually more, in design :;-)