World: r3wp

/skip return records
i.e.  
>> select/skip [1 2 3 4 5 6] 4 3
== [5 6]

I'm just missing MAP! in R2:

>> m: make map! [1 2 2 3]
== make map! [
    1 2
    2 3
]

>> select m 2
== 3

Fortunately the /skip in SELECT/skip is ignored for map! in R3, so 
you can just use it in both.

Darn the R2 version does a copy/part. Silly differences.

in R2:
>> make map! []
== make hash! []
>> m: make map! [1 2 2 3]
== make hash! [1 2 2 3]
>> select m 2
== 2

which is not what I woul expect

Seems like map! is just redirected to hash! . Can be seen with
	? datatype!
, and that's probably confusing, as they behave differently.

Can also be seen with
	? "map!"

>> source to-map
to-map: func [value][to hash! :value]

Is there an official documentation of
	make struct! ...
?

Is there documentation of constructs like #[none] ?

http://www.rebol.com/docs/sdkug.html

see "External Library Interface"

There it was, thanks!

I don't see doc about C datatypes in struct! spec block. I guess, 
it's the same rules as in routine spec block?

Example, where I use the C datatype, int:
	>> s: make struct! [i [int]] [42]

About constructs, off my head I have:
	#[none] #[true] #[false]

Are there others?

>> #[binary! "abc"]
== #{616263}
>> #[bitset! #{010203}]
== make bitset! #{010203}
>> #[block! [1 2 3 4] 3]
== [3 4]
>> #[email! "something"]
== something
>> #[file! "something"]
== %something
>> #[function! [a b] [a + b]]
** Script Error: none is missing its a argument
** Near: func [a b][a + b]

... and so on

Is this documented anywhere?

Perhaps not, geomol. See this cc thread:
   http://curecode.org/rebol3/ticket.rsp?id=941

The "serialized" word is very inappropriate, e.g.:

    /all "Mold in serialized format"


does not say anything at all, since the format without the /ALL refinement 
is serialized as well (it is a text string).

Some other inappropriate notions:

   "serialized constructors", when used for #[none]


e.g. is a very unfortunate notion, since it is not a constructor 
(=a special function), not to mention, that it surely is not a serialization 
of such a function.

(my notes apply to the text of the curecode discussion to the above 
mentioned ticket)

Fortunately, according to Carl's note, the correct notion for the 
#[none] and similar formats seems to be:

    "specially escaped format"

Does serialization not imply there is a reverse action for it? Only 
MOLD/ALL will allow that.

Hmm, that looks like a proper objection, but it does not take into 
account, that e.g.

    123


is a result of both MOLD as well as MOLD/ALL and it surely is serialized, 
while e.g.

    #[none]


is not just "serialized", it is a "specially escaped format", as 
noted by Carl

Moreover, MOLD usually does preserve REBOL code in the sense, that 
you get the same program when loading the result of MOLD more often 
than not.

While even MOLD/ALL does not look "reversible enough" for some functions, 
objects, etc.

For all the above reasons, it is much better to call the #[none] 
and the likes "specially escaped format" rather than "serialized 
constructors".

The unfortunate thing is, that there is the MOLD vs. MOLD/ALL ambiguity, 
which confuses every beginner exactly because when they encounter

    none


they usually think it is a REBOL value of the type NONE!, which may 
mislead them in many cases

do we have both MOLD and MOLD/ALL for performance reasons?

I do not think there are performance reasons for that.

why do we then have MOLD and FORM?

rather: why do we have MOLD at all? I'm not sure we can say that 
it preserves REBOL code, because, surely, MOLD/ALL preserves more 
of it.

For example, if MOLD/ALL were used to display the result of an expression 
we would obtain:

    none
    == #[none]

, which would be less confusing than

    none
    == none

but we use FORM for that, don't we?

the only place that I find use for MOLD is when wanting to preseve 
brackets when displaying a block. otherwise I use FORM or MOLD/ALL

no, MOLD is used to display the result of REBOL expressions as far 
as I know

That's not how I originally understood it, when I first read about 
them. Displaying values was the intent with FORM as it does not necessarily 
produce REBOL readable output, but human readable output. MOLD was 
meant to be used for serialization, so that the data could be re-read 
by REBOL.

Indeed, the help strings:

FORM: Converts a value to a string.
MOLD: Converts a value to a REBOL-readable string.

>> print ["==" mold "a^^b"]
== "a^^b"
>> print ["==" form "a^^b"]
== a^b

So, it is clear, that MOLD is used, not FORM

you mean, when returning a value to the console?

you mean, when returning a value to the console?

 - it is not "returning a value to the console", it is "to display 
 the result of a REBOL expression in the console"

that's different than "human readable output":

>> "a^^a"
== "a^^a"

>> print "a^^a"
a^a
== "a^^a"

'that's different than "human readable output":' - I do not understand 
what you are after saying that

the output is clearly different from PRINT than from MOLD.

The current state: 


- MOLD is used to display the result of REBOL expression to the console.
- I prefer MOLD/ALL to be used, since it would be less confusing
- do you mean, that you would prefer FORM?

I'll rephrase:


What I have a problem with, is that there are apparently degrees 
of serialization:


One that we call MOLD, but doesn't really work on all REBOL data. 
I very rarely use this alone.

One that we call MOLD/ALL, and works on nearly all REBOL data. I 
use this very often.


Then we have FORM, which should work on human readable output. The 
problem with FORM is that it isn't flexible enough. For example it 
should have been capable of reformatting numbers, such as 2E-3 to 
".002". It doesn't do that.

R3 does

Yes, R3 does (I wrote the code, as far as I remember), but it is 
arguable, whether it is true, that ".002" is human readable, while 
"2e-3" isn't.

I know that everything is human readable to Ladislav, that's for 
sure. :-)

Not everything, *that* is for sure.