World: r3wp

Geomol - you should seriously serialise :-)

heh

Well, Henrik, I suppose the none word holds the none value, and if 
it does, it probably works as intended. If people want to redefine 
none, then it would mean something else. And then what? I don't see 
a big problem needing constructs in there.

If a writer write
	fromage

what does that mean? In Denmark, it's a dessert, in France, it's 
cheese.

So I need to seriealize that word to hold the meaning?
Nah, I don't think so.

The meaning comes from the context.

Interesting, that after writing

    mold/all [undo [true]]


and wondering why you did not obtain what you expected you still 
don't see that you confused words and the possible values that may 
have been assigned to them.

Geomol, the context is not relevant during serialization, so stating 
that "I suppose the none word holds the none value" is incorrect. 
It is the unreduced contents that are important. Also you don't have 
the index of the block.

Let me reveal what my-block actually contains:

my-block: next reduce [true none 'none]


That information is only available in the serialized format like 
this:

>> mold/all my-block
== "#[block![#[true] #[none] none]2]"

Yeah, I wasn't very sharp, when I wrote that mold/all example, Ladislav. 
:)

As I see it, the problem is not that you "wasn't very sharp", the 
problem is, that the practice of displaying words and their values 
the same way *is* confusing.

That information is only available in the serialized format like 
this:

Why isn't it available using the do dialect, like:
	do [next reduce [true none 'none]]


And then you say, because DO, NEXT and REDUCE may not hold the meaning, 
you expect. 2 points:


1. Right, but is it worth the effort, if those are being redefined?

2. Why SAVE series like that at all? Why not save HEAD series and 
then maybe an offset, if you need it?

Ladislav, isn't it only confusing, if those words are redefined?

And redefining those words in the first place is confusing, so this 
bites itself in the tail.

Geomol, you don't know how the data is generated, if you are getting 
the data from disk or network, where you are surely not haplessly 
DOing things for security reasons. You are capturing the state of 
the data. Without such a state capture, much of REBOL is rendered 
useless.

Ladislav, isn't it only confusing, if those words are redefined?
 - no, and the example you used demonstrates that

(I mean the mold/all [undo [true]] example)

So, to constrain this, constructs are useful for values, you don't 
wanna do (because of security reason, if e.g. the data came over 
the network). Therefore there is no need to make constructs for natives, 
operators and functions?

there are constructs for functions. natives and ops can obviously 
not be serialized and don't need to.

What if you want to send this information:
	[next "abc"]
, where next is the native NEXT ?

If you can't serialize NEXT, it can mean anything, right?

then you send it, and when loaded, 'next is executed, no?

Eh, no.

Geomol, you can't present NEXT that way. In that block, it will be 
a word:

>> reduce [:next]
== [action]

Ok, confusing with the block. Forget that.


What if you wan't to send the information: evaluate the native NEXT 
working on the string "abc" ?

simply send the block [next "abc"] and DO it in the other end (if 
you dare)

Geomol - if I send you my script, which contains [next "abc"], and 
you just DO it, then it will work, or not? :-)

But you can't be sure, it's the right NEXT. Same resonnement with 
NONE, TRUE, FALSE etc. Or? :)

Geomol, context, as usual, is irrelevant during serialization.

Sure, it always depends upon the context. In some context, 'next 
might not refer to the native function.

Pekr, yes exactly, it would work, because NEXT here means something. 
My point is, the same can be said with values like NONE, TRUE, FALSE 
etc. So why have constructs?

Serializing NEXT has no meaning, because it's a native, that already 
exists in REBOL. There is no state we can save with it and there 
is no need to transfer that information.

Can't the same be said with the value, NONE holds?

The value that NONE holds is irrelevant.

http://en.wikipedia.org/wiki/Serialization

Is the following statement valid?


Because in REBOL, code is data, serialization doesn't make sense, 
when native functions and operators can't be serialized?

I'm not sure that is valid, because, if you move to other languages, 
where code is not data, you don't serialize "natives" there either.

Ladislav, a better mold/all example is:

>> mold/all reduce [:until reduce [true]]
== "[native [#[true]]]"

What I usually use to differentiate these is that there are literal 
values which do not have to be interpreted (only parsed), and logical 
values which have no real meaning without this interpretation.

Serialization

 in the REBOL sense, hence the quotes,  is used to give the second 
 form of data a way to be described in the first, *where its possible* 
  which it isn't at all in the case of some types (native,etc) and 
 only partially in others (objects!, functions!, etc.)   


even with these distinctions there is still a sizeable amount of 
REBOL *data* (interpreter values, not human visible source code) 
which cannot be serialized (in the real sense) in any way because 
either:  

-the notation has simply not been defined for it (cyclic series/objects, 
which is serializable in other languages)

-it implicitely depends on its interpretation (a VID dialect block 
(you cannot save the vid from the faces)), custom types (in the future))

so the way I see it is that: 
-MOLD is the counterpart to DO
-MOLD/ALL is the counterpart to LOAD.

which leads to saying that:

only MOLD/DO can effectively represent all data,  (with the caveat 
that it is extremely insecure)

only MOLD/ALL can effectively represent literal data without interpretation 
(with the caveat that it is not complete)

BOTH , are highly complex to use effectively in non-trivial cases. 
  


IMHO, if it's notation where completed, the second form could actually 
be built to represent all data, since it could be built to include 
binding hints, series reference graphing and more.  It doesn't have 
to be pretty, it just has to be symmetric.

I think, that the point here is the Geomol's question:


I still ask myself, if all those constructs are really necessary 
taking the amount of work and time used into account.


The answer is quite simple, it is as with any data the Load dialect 
can represent:


- many data representable by the Load dialect aren't "really necessary"

-- other languages can usually represent less data types than the 
Load dialect can

-- the Load dialect did not have the escaped format from the start, 
and could do without it


- without the escaped format, the Load dialect cannot express values 
of the logic! type


- it is useful to be able to express values of the logic! type in 
the Load dialect
-- some languages have the advantage of being able to do that

-- it is confusing to use a word like true in the Load dialect, when 
meaning the logic value, since in the Load dialect true is a word, 
not a logic value (notice the example, where Geomol confused words 
and their values)

-- the expressibility of the logic! datatype in the Load dialect 
enhances the expressivity of the dialect, which is why it is useful 
to have it, similarly as for any other datatype expressible

-- the expressibility of the logic! datatype enhances the reflexivity 
of REBOL, since 

--- this way, the Load dialect can express values that would be otherwise 
inexpressible in it, while being used in the Do dialect

--- that means, that the Load dialect would not be usable to "speak 
about" logic values in a direct way

That was my answer as far as the usefulness of the #[true] and #[false] 
values is taken into account. Similarly, the usefulness of #[unset!] 
and #[none] is quite unquestionable. As far as the usefulness of 
the other representaions goes, it may be more questionable to have:

- escaped format for objects, because

-- some objects are not describable precisely enough using the current 
escaped format

-- nevertheless, the ability to describe a result of a REBOL expression 
this way is useful at least sometimes, since for me, the #[object! 
...] clearly communicates e.g. the fact, that it is one value, while

--- make object! [...] are, in fact, three values in the Load dialect, 
as Geomol noticed


- similar notes can be written about the escaped format for the function! 
datatype


- the escaped format for natives, (which exists only in R3) is even 
less useful, since it is not loadable, so, in a strict sense of the 
word, it is not even in the Load dialect

-- but (arguably) it can still be used to describe a result of an 
expression when such a demand occurs

The only problem right now, is that the serialized form of the language 
is just not complete. all the edge cases I can think of have a way 
of being resolved, especially in R3.

having cyclic references be checked and used on object/block types 
would already go a very long way.


#[block  1  [ val1 val2 ...]] ; serialized block with uid as first 
parm (only needed when it is shared in the string being loaded).
#[block  2  [ val3  #[block 1]  val4]  ; shared block
#[block  3  [ #block 3 ]]   ; self-reference


effectively shows a simple way to solve the cyclic series/object 
problem.

The only problem right now, is that the serialized form of the language 
is just not complete.

 - I would say, that "the Load dialect is not complete relative to 
 the Do dialect", being unable to express some values of the Do dialect.


Nevertheless, the question arises, whether the relative completeness 
is necessary. For example, you demonstrated how cyclic blocks could 
eventually be handled, but, I am not sure you do suggest your solution 
to be used, or just demonstrate the possibility.

Moreover, when I look at it, I have to say, that it actually would 
not be acceptable, since when you do want to mold e.g. your block 
3, you should obtain a representation of one block

Aha, wrong example, I should have used your block 2 as an example

You forgot to mention: Natives, actions and ops aren't properly serialized 
for a couple reasons:

- The native references wouldn't necessarily be valid between versions.

- It breaks the security constraints, giving access to natives without 
requiring access to their contexts.

Today's Moment of REBOL Zen:

>> s: "abc"
== "abc"
>> t: copy next s
== "bc"
>> index? t
== 1
>> b: []
== []
>> insert b next s
== []
>> index? b/1
== 2
>> p: copy/deep b
== ["bc"]
>> index? p/1
== 2


So copy/deep a block does not use copy on each member of the block 
in the normal sense of copy.

I'm not sure to see your point.

But If you want to see if the series are the same or not you have 
to use same?
Actually, Your trial does not  prove your claim

Maybe the following makes it more clear?

>> b: []
== []
>> s: "abc"
== "abc"
>> insert b copy next s
== []
>> index? b/1
== 1

When copying a string, you get what you see.

When copying deep a block containing strings, you get more than what 
you see.

Yes, the string is copied in both cases. The difference is that  
copy/deep copies the whole string not only the part that is maked 
by index.

Neither, sorry :-)
index? never gives the absolute position.
just try index? head b/1