World: r4wp

Note that, even if DO and LOAD currently don't work on files, you 
can still use:

DO READ %file

DO READ "url"

ok, good enough for now, I guess.

Red HELP func made some decent progress, but I stopped work on it 
because of some issues, and I didn't want to distract Doc until he's 
done with Android.

I looked at REBOL WHAT function, Kaj mentioned. I don't think, I've 
ever used it. Is it commonly used by you guys?

Almost never for me.

BTW, my Red HELP experiment is here, under %Red/mezz/. You can paste 
it into a Red console to test.

Ah, yes. One issue was that calling HELP with no arg crashes the 
interpreter.

I might have stopped until we have errors in Red, because debugging 
by crashing is hard. ;-)

yeah :)

But also shows that you can still do a lot in Red, even without it. 
Most of the mezz code I did works.

WHAT is quite essential on Try REBOL for new users

It's never struck me as a great name. I just always use HELP. e.g. 
HELP function!

It's very introductory, like What, Why, When, Where. You need that 
before you know to do HELP function!

I found a bug in the interpreter that currently prevents me from 
overriding DO:

https://github.com/dockimbel/Red/issues/482

Except, we don't have WHY, WHEN, or WHERE. ;-)

World should have a WHY??? :)

I don't see how that devalues WHAT. :-) And R3 has WHY?

I don't remember which, but I think there are old computer systems 
that list available commands with WHAT

WHAT is to find out what stuff is attached under an object. I use 
(d) it a lot with VID, finding out which field was filled with what 
value to see how I could go about dynamically change the properties 
like captions and values and colors.

Arnold, isn't that what HELP (or the ? short) is used for? WHAT seems 
to "Prints a list of globally-defined functions.".

You are completely right, I stand corrected. Sorry, mixed them up, 
not using it as much lately.

Would it makes sense to add languages like Verilog as target / code 
backend to Red/System?

Probably the WHAT has served an important purpose during development 
of REBOL?

I couldn't say. I don't have any memory of WHAT, until it was mentioned 
here yesterday.

I used WHAT many times, and also  when showing/demonstrating rebol 
to other people, what is built in

If someone needs verilog, they can add it (or pay Doc to). I need 
I/O and some networking, and the core stuff like errors and objects.

Yeah, I was just thinking, if it makes sense at all to include a 
language like Verilog in the way, Red/System is made today. I haven't 
looked deeper into it. Maybe it makes more sense to create a cross-compiler 
from Red/System to Verilog and such, totally independent of the code 
backend found in Red/System?


Maybe Red/System could be the base for all different kind of hardware.

I would probably think to implement as a high level dialect in Red 
that compiles down.

Isn't that the other way around? I want to go from Red/System source 
to Verilog and other similar languages for different hardware. I 
don't want to start with a Verilog program and end up with what Red/System 
produces.

Doc wants to program FPGA CPUs dynamically one day, so there is a 
sensible route in there somewhere

What I mean is, I want to write the Verilog/VHDL dialect in Red, 
and have it compile down.

Gregg, you have a fine taste of useful tech ;-)

I guess this is a huge task. If you look at the Xilinx ISE Pack and 
the prices they are asking...

There is a free Web version but this one only supports the very small 
units with max. 24k LC, not enough todo usefull things.

But of course a Verilog/VHDL dialect would be more than cool. Meanwhile 
OpenCL/CUDA would be nice as well.

@Doc: found problem about console windows. I use the function _system() 
twice so I have two windows so it is my fault, sorry.

Doc, is your plan for Red PARSE to use R2 dialect, or R3's?

I am for R3 including enhancements, but Doc does not plan to support 
features like to [a | b | c]. Whereas I am almost refusing to use 
parser without it, Doc seem to be against stuff, which would eventually 
slow down the parser. And as the parser will be most probably implemented 
by Gabriele, we might get some compile rules or something like that. 
I am for R3 compatibility though ...

I agree that TO [a | b] is very important in a parser. I was surprised 
when I found that R2 doesn't do it

Isn't it just a nice thing to have? You write less, yes, but you 
could just parse for
	[to a | to b]


Some might even argue, that if you have a lot of alternate rules, 
it is more readable to have the keyword, TO, together with the alternates.

Geomol,
    [to a | to b]
is not equivalent (not even nearly) to
    to [a | b]

ok Then it's a good argument.

However, it is questionable whether a user unable to replace
    to [a | b]
by an idiom like recursive
    rule: [a | b | skip rule]
can be actually able to use Parse...

I feel, you need to explain this. If I replace a with "abc" and b 
with "str", and I want to parse ["abc"] :

(From R3 prompt:)

>> parse ["abc"] [to ["abc" | "str"]]
== false

>> rule: ["abc" | "str" | skip rule]
== ["abc" | "str" | skip rule]

>> parse ["abc"] rule
== true

Or did you mean

rule: [to a | to b | skip rule]

?

Ladislav - I am able to user parse, used it even for some more complicated 
stuff, including recursive rules. But - it was mostly trial and error 
on my side. OTOH - parse should not be reserved just for gurus imo.

Geomol - try to understand your example. Imagine html file for e.g. 
Your [to a | to b ...] is wrong ... imagine 'a is at the end of the 
file. Simply "to a" will find it, before "to b" is even given chance 
to be applied. What we want is - find what is first - 'a or 'b ....

Geomol, I certainly did not mean the idiom you suggested. I just 
used an idiom for THRU, which can be adapted as follows::

    a: [here: "abc" :here]
    b: [here: "str" :here]
    rule: [a | b | skip rule]

Pekr, ah :) Early in the morning here, so I need to get in gear. 
Good point!

Idiom I long time wanted - to [a | b] might be more expensive imo, 
as it will do incremental searches, evaluate the lower index and 
apply the rule. Whereas recursive [a | b | skip rule] will skip one 
positition at a time, trying to match rules .... or that is how I 
imagine the difference :-)