World: r3wp

I said my book wasn't clear because in presenting blocks, it uses 
the words "arrays", then "lists" and "series" inside : it's quiet 
confusing.

I guess, words like "arrays" and "lists" are common in other languages. 
In REBOL, you'll see the word "series" a lot.

A block is a series of elements (inside [ and ]).

Geomol: ok, but is there any difference between all these terms ?

Try in the REBOL console:

>> ? datatype!

you can ask whether a datatype is a series with 'series?.

So what's the difference between a block and a serie ? A serie is 
a block for me no ? (the inverse may not be right)

not all series are alike. We tend to differ between strings and blocks 
and blocks come in a few different types, optimized for specific 
use, but they may hold the same content.

A computer language theorist might tell you differences between arrays, 
lists and series. I suggest, you take the practical view and look 
at what datatypes, you find in REBOL.

kib2, let REBOL decide what is what, by asking the datatype:

>> series? [a b c]
== true
>> series? "abc"
== true


You can do that, because REBOL has so many different datatypes, allowing 
you to be precise in your expression.

>> series? "abc"
== true
>> series? []
== true
>> series? make list! 10
== true

So there are many kinds of series.

Geomol: Rebol is the langage where I've found the more datatypes 
!

hehe :-)

kib, me too.

if we didn't have this many datatypes (R3 has even more), parsing 
and dialects would be less fun.

kib, you'll see, the number of datatypes is one of the really really 
huge forces of rebol.

email!, url!, money! etc. That's good when you parse something

Henrik: R3 adds other datatypes ? like ?

yeah, email! is actually an exception. it doesn't work very well. 
you will find that a few types can't be serialized properly, which 
means an email! can't be recognized. but it works for the majority 
of types.

Or when you use functions:
read %disk-file
read http://www.rebol.com
(or reading some other port)

kib2, percent!, task!, vector!, gob!, handle!, closure!. There are 
more.

plus in R3 you can define your own and group types in new ways.

really impressive

using typesets, you can say something like:

>> image-type: make typeset! [binary! image! url!]
== make typeset! [binary! image! url!]

(doesn't make that much sense, but you get the idea.)

(that's also R3 only)

Henrik, is there an example of a user defined datatype in R3 somewhere?

wow, you can make your own and combine.. that seems very good!

kib2, using MOLD/ALL, you can study serialization, on how to build 
serialized blocks of data.

cool and powerful, but we've to wait until R3 gets more stable.

Geomol, try: ? typeset!

Some interesting ones turn up.

actually only one at this point (scalar!), but I think there will 
be more, if it makes sense to have them.

Henrik: :)

kib, you had other questions from reading the book?

Will R3 also have something like multiple dispatch then?

explain? (I'm not good with terms)

Geomol: yes, it's more practical : do you often use globals ?

No, I try not to. It's nice to have kind of globals in a long script, 
to easily share values between functions, but then I put the whole 
thing within a context block, like:

context [

... all my code go here ...

]	; end of context

That way my "globals" isn't really globals, they're local to my context.

Henrik: I am not very good either :) ..  I will try to find an example

Geomol, the reason you do that, is of course to avoid garbage collection 
of said "locals"?

CONTEXT is a function, and you can see, what it does with:

>> source context

context is used for that purpose ?

context is just another word for "make object!"

ah ok.

and objects are contexts. when wrapping set-word!s in contexts, they 
stay inside that context.

Henrik, no, not really because of garbage collection, because the 
garbage collector doesn't collect words defined 'globally', right? 
I do it, because it's good programming practise to not have many 
globals. :-)

Henrik: that' seems a good way to handle namespaces ?

kib2, you'll find that many scripts come wrapped in contexts. this 
is the best we can do until R3 brings us modules. contexts are not 
waterproof, though.

context [
  a: 1 ; only inside context
  set 'b 2 ; global
]


This can be useful, if you want to create an object with one "public" 
function.

>> 3 + 2  == 5
>> 3x2 + 2x3 == 5x5