World: r3wp

It seems rebdev mobile is down right now, so I made a screenshot 
of Steeve's example post:

http://rebol.hmkdesign.dk/files/r3/gui/182.png

>> a: "this is a test [now a block] garbage [another block with a 
block in it []][and another] garbage..

 == {this is a test [now a block] garbage [another block with a block 
 in it []][and another] garbage..}
>> get-block a
== [now a block]
>> 
 get-block a
== [another block with a block in it []]
>> get-block 
 a
== [and another]

My get-block function just advanced automatically through the string.

anyone know which sort algorithm that R3 uses for it's sort function?

Paul, yes i do by using  the standard copy/part function.
>> copy/part v-block 10
== [ first-value second-one etc...]

copy is auto advancing in the block, so that if you do several copy/part 
at once , you will get several sub blocks of values.

So 10 would equal ten blocks read?

yes

Can it handle newlines in the block contents?

it works in reverse order either.
>> copy/part  tail vblock -10
get the last 10 values of the block

Yes Paul, it does

Good, it is sounding nice Steeve.  Hope to see it in R3.

Yours sounds like what Chris wants to do.

even it it's not in core R3, it will be downloadable.

Nice Steeve.

i will release the first version in some days or hours, i need to 
write more documentation

Please post in ALTME as well.  I would like to check it out.

rebdev private msging fixed ..

Will R3 introduce function overloading?

Nope, functions are still values.

ok..

Which is incompatible semantically with overloaded functions. You 
can only overload functions in languages where functions are declared, 
not where they are constructed and assigned.

Correct, how about default parameter values when no arguments are 
passed and a function is invoked?  That would be a nice feature to 
have.

We can do this now in a more complicated manner.

I guess that could be related to the declaration issue also though.

No, that's feasible in theory, but only for arguments that are optional 
in the REBOL style, using refinements (or any-type! for the last 
arguments) - REBOL's evaluation model depends on knowing the number 
of arguments. In practice the current method may be more efficient 
- we can see. That could be handled by a function construction function, 
i.e. FUNC, HAS or DOES.

Declaration is not the issue here, it is the lack of parentheses.

We can currently do default values in R2.

Yup, likely using the same function construction functions as R3 
if you like. Unlike FUNCT and FUNCTOR, that problem doesn't sound 
like it would require anything new to make things easier.

I can already do something like this:


fnc: func [a [unset! string!]][either value? 'a [a][a: "I got value"]]

but it would nice to be able to do something like this:

fnc: func[a [string!] /default $10 ][print a]

fnc 
>> $10

where anything after /default is a default value for the respective 
parameter.

Note that your parameter was the last in the list, the second condition 
mentioned above. That would only work if the calling expression was 
the last in its block because of REBOL's evaluation rules.

Which is even more reason why the second example would be preferred.

The evaluation rules of REBOL can't change without requiring parentheses 
or something around function arguments.

I didn't know how deep changes were being made with respect to R3. 
 Maybe a wish for R4.

Default values for parameters that are not the last parameter would 
need to be made optional using refinements. You *really* can't change 
this, not even in R4.

Seems odd to me.  What language is REBOL written in?

C and REBOL, with some C++ in linked libraries (AGG).

Then it is doable from that standpoint - must be another reason that 
it wouldn't be done.

It has nothing to do with the implementation language though - it's 
a syntax thing.

In C++ for example the defaults are set as follows:

int fnc (int x = 1 int y = 2){...}

I can understand the syntax issue from the perspective of it requiring 
the parameters defaults be ordered.

Languages that wrap function arguments in parentheses (like C and 
Pascal) or are line-oriented (like Basic and Python) or at least 
have statement separators (like ; ) have a way of telling where their 
argument lists end. REBOL can only do so if the arity of a function 
is determinable at the call site. This is the price we pay for getting 
rid of the parentheses.

Yeah, I wish Carl would give more specifics on the internals sometime.

That is not a matter of internals, it really is a consequence of 
REBOL's evaluation rules. You can't change it without changing the 
language in drastically incompatible and slower ways.

Ok, i made a demo using the virtual block scheme (tested only with 
the last alpha)
Sorry for my frenglish
http://www.MegaShare.com/573256

Why you use such a site instead of using for example rebol.org?

it's small.

the scheme size 4,5 Kb, i add documentation, so now it's huge 10 
Kb

Oldes, it's a first try, then i will post it in rebol.org