World: r4wp

It doesn't scale well, and as you can see in the following example, 
it can quickly get nasty:


    [/external obj1 [a b] /external obj2 [c d] /external obj3 [e f] /global 
    g h]

thanks for explanation. Having vars locally by default is one of 
the few nice aspect  of php. But as you said, in objects methods 
probably this leads verbosity.

You can't arbitrary pick a feature in one language and drop it in 
another one and expect it to have the same benefits...especially 
when they are so different. ;-)

That design note would make a great doc entry somewhere. Is there 
a Red wiki where we can stash these things, or what would be the 
preferred method at this point?

Davide, FUNCT in R3 declares all set-words in the code block as local 
by default. The commit comment says that Red's FUNCTION will act 
like that.

Doc, will FUNCTION have some of the other options that FUNCT has? 
(Feel free to adopt the FUNCT code: I wrote it.)

Now Red supports 21 datatypes. In the following R3 datatype list, 
datatypes with a minus prefix are not supported in Red yet.


action -binary -bitset block char -closure -command datatype -date 
-decimal -email -end -error -event -file -frame function get-path 
get-word -gob -handle -image integer -issue -library lit-path lit-word 
logic -map -module -money native none -object op -pair -paren path 
-percent -port -rebcode refinement set-path set-word string -struct 
-tag -task -time -tuple -typeset unset -url -utype -vector word

just a note: there is absolutely no need to support the end! datatype. 
REBOL doesn't support it either, in fact.

Jerry, I am not sure, I would post such a list, especially to Red 
FB channel. It looks almost discouraging. How will you measure the 
quality of Red e.g. running on ARM, and R3 not?

Moreover - Red is not a clone of R3, some things might be done quite 
differently in the end imo ....

Jerry: command!, end!, frame! and rebcode! are very unlikely to be 
adopted in Red. Also following will probably not be part of Red too 
(or not in a near future): event!, gob!, handle!. Meaning of decimal! 
will most probably be changed, float! or real! will be used instead. 
Money! will receive a different treatment than in REBOL (number of 
digits after comma will probably be adjustable).


Also, expect the return of hash! in Red, and new datatypes that do 
not exists in REBOL.

As you can see, it is not a 1-1 matching between Red and R3.

Routine! will also probably be back in Red.

I agree with Peter, you can't measure Red's progress by taking R3 
as a target goal. It is better and more accurate to measure progress 
by counting what is built in Red.

struct! doesn't work in R3

task! seems to work half or so

As far as I know, utype! doesn't work

rebcode! is not implemented in R3

Doc - interesting - I know you have no intention to port View, but 
what about other types of events? Will not be there an event type? 
I want my wait-list with various events - networking, serial port, 
whatever :-)

Kaj, rebcode! isn't really in R2 anymore either. But the mechanism 
that was used to make rebcode fast in R2 has been implemented in 
R3, and it used by the R3-GUI dialect. Anyone could implement their 
own rebcode if they like, even with improvements. That mechanism 
would be worth supporting in Red.

Hopefully less buggy too. The rebcode dialect caused a lot of crashes 
and security holes, which is why it was removed. The new mechanism 
doesn't have that problem.

Petr, I haven't decided yet how events will be presented to user, 
there are different possible options and the choice will depend on 
the implementation constraints. Once we have the I/O + tasking implemented, 
we'll see what interface is the best for exposing events to user.

Too bad about command!, that function type is the best one for pluggable 
JIT compiled function models. There are other advantages too.

Let's not rehash the hybrid extension conversation though :)

For handle!, what type are you using to be an opaque pointer-sized 
type that all pointer operations are prohibited on? Can such a thing 
be typedefed?

If you had an ability to create an opaque value of any size that 
will fit in a value slot, or maybe just limited to pointer size, 
only accessible from Red/system code, that would be a good replacement 
for handle!.

I haven't decided on that yet. I need to implement first the type 
marshalling interface between Red and Red/System and see then, what 
is the best option.

Interesting info, Brian. However, I wonder what rebcode! would be 
needed for when you can inline Red/System

The advantage to rebcode isn't that it's fast, it's that its semantic 
model is similar to assembler. That makes it useful for a lot of 
interesting problems. Also, there might be times when you don't want 
to allow Red/System to be inlined - it's basically the same as unsafe 
code in C#, with the same security characteristics.

Yes, but RebCode is aimed at an interpreter. In Red we can make any 
safe dialect we want that compiles to Red and/or Red/System

If Red's compiler is implemented well, there shouldn't be any reason 
that it would be slower than the equivalent Red/System code. Red/System 
is just less safe.

In Red, there might be an advantage to making a compiled rebcode 
equivalent (but without the stability and security bugs). Unlike 
REBOL (ignoring the debate), rebcode is inherently compilable. It 
wasn't designed to be interpreted the way REBOL was. It just had 
a fast interpreter implementation, which has been adapted to other 
dialects in R3.

Right, found it, the DO-COMMANDS function. That is what implements 
the rebcode interpreter model. And it's another reason to have a 
command! type.

Sure, but Red and Red/System are also inherently compilable. I think 
there's very little advantage left in a virtual assembly dialect

Inherently compilable

 alone still leaves open a wide range of design possibilities. "Redcode" 
 could still explore design spaces opened up by a quite reduced source 
 language.

I guess the intermediate format in Red/System 2 will get you that

Yes, possibly.

Inline that, and presto: RedCode

BrianH: is the command! dispatch interface the same as DELECT?

DELECT takes a dialect that prepares the commands

Doc, regarding decimal!, do you mean the implementation will be different, 
or are you planning to use float! or real! as the datatype name?

The latter. I would like to keep decimal! name for a new BCD datatype.

I want to compliment you on the speed of development of Red! It is 
truly amazing. Keep up the good work.
Is this news also worth mentioning on the red-lang.org website?

Thanks Arnold. Not yet, I will make a 0.3.1 release for that, but 
it needs a few more days to stabilize.

FYI, I have started working on EXIT and RETURN implementation. It 
will probably take a day to design and implement them correctly. 
In the meantime, feel free to push issues with Red functions on the 
bugtracker.

Haven't read commints, so sorry if already answered - will there 
be a FUNCT equivalent, allowing to use local words only?

FUNCTION. It's mentioned here: https://github.com/dockimbel/Red/commit/cc5c8dcb839572bb25559f964ed7d30419cb5a31

Thanks Doc. I support the idea of decimal! as the BCD type.

Doc, I can see Rudolf being pretty active with testing Red, Red/System? 
Nice, I thought we have lost him when R3 went into a non-development 
mode ....

He showed up again shorter after Red first alpha release. He's working 
on updating the BNF grammar of Red/System to add namespaces.

No gob! Does this mean no GUI or just gui done in different way?