World: r3wp

To a lesser extent, I had also a weird feeling with FUNC word, but 
it vanished rapidly, I'm very used to it since years now.

The distinction between Red and Red/System is almost as big as between 
REBOL and C.

I accepted PRIN the first time I saw it, just going "oh" and memorized 
it for what it did. I don't agree that Red being a fundamentally 
different language means that you must rename trivial functions. 
That just means there are more differences to learn.

that's it - you just get used to it. Now imagine your source code 
- if Oldes is right, then 99% of time you are going to see print-line, 
instead of print, in your source code. Well, it depends how often 
do you actually print :-)

It's a more common way of abbreviating than leaving off one letter. 
Still, I changed all my FUNCs to FUNCTIONs in Red/System

Red/System is aiming at being a dialect living inside Red, for system 
and bare-metal programming.

I accepted PRIN as well... and as I said, it's usage is really rare. 
I would prefere PRINT to do line break.

Doc - yes, but as I said - will there be many users, using just Red/System, 
not using Red, and vice versa?

Everyone will use Red, some library developers or system programmers 
will also use Red/System.

If not, the mindset is closer than you might think. If someone is 
going to use only Red/System, which you claim being closer to C than 
Red, than such person can just use - a C :-)

I will not use print-line for sure:)

You have ?? instead. ;-)

But - as Red/System is mostly out of my scope, I will acept any decision 
...

Also, it's too early in the project to be nitpicking, you'll have 
plenty of time for that when Red will be out. ;-)

Will some alpha Red come in 2012?

That's what I said -not an important issue, I just wanted to state 
my opinion, that 'print, if used in 80+ cases with new line, should 
do so :-)

Do you want to use ?? in RED as well? Because as Pekr said, it will 
just cause confusion... I have enough problems not to write TRACE 
instead of PRINT :)

There are other ways of looking at it. For example, code is read 
most of the time rather than written. PRINT-LINE is very clear for 
reading

Another view is that a very small audience of REBOL programmers is 
used to PRIN. The big audience for Red is people that don't know 
or even dislike REBOL

Kaj - yes, most of ppl are used to print, which will almost not be 
used, as it does not print a newline - that is also another point 
of view at it :-)

By most of people, you mean REBOL people

yes, because most Red/System users, are going to be also a Red users. 
Red/System is not for C ppl, that is an illusion imo. Why would anyone 
C oriented would like to use Red/System, if he/she would not also 
want to use Red later? :-)

REBOL itself is incompatible between R2 and R3
 - counterexamples:


- my INCLUDE is a complicated script that is working in both environments, 
i.e., the compatibility surely isn't "incidental" in your own words

- the core-tests suite is working in both environments as well, containing 
more than 3000 interpreter tests

Do you mean that's proof that R2 and R3 are compatible?

What else should be?

Well, now I restrain ... I am most probably not going to be a fluent 
Red/System user, so I don't want to influence such a decision, if 
other ppl feel differently about the topic ...

I'll have to refer you to Boolean algebra

Also, I didn't say "incidental" about R2 and R3, I said it about 
Red and REBOL

Well, I can describe more compatibility examples like Brian's backward 
compatibility library, but I think it is absolutely unnecessary having 
mentioned the common interpreter core tests. However, I am curious 
how is that related to Boolean algebra?

Your statement seems to be that R2 and R3 are compatible. Examples 
cannot prove that. Counterexample falsifying that: for my CMS of 
towards 4000 lines, although I wrote it in basic R2 to avoid porting 
issues, I had to make extensive changes throughout and a number of 
alternative functions and wrappers to get it to work on R3

The other way around, there are web sites I can build correctly on 
R3 but not correctly on R2

To put my two cents in: I disliked PRIN the first time I saw it, 
and I still dislike it everytime I have to use it, 10+ years later.

I also find myself using PRIN regularly (i.e. much more than 1% of 
the time I _don't_ want to print a newline right away).

Pekr: I fully agree with the 80% (or 99%) usage argument, the issue 
is not there, it is in finding a suitable name for "print-without-LF" 
if PRINT is used for printing with LF. Last time we tried that, we 
didn't find any good solution, so we ended up with a single PRINT 
command to cover all use cases.

the name has to be similar but suggest it is somewhat less .. so 
how about -print ?

or, print-

I suspect that is why the t is missing for 'prin ... but then you 
have to know what it stands for

I've renamed the print-string in the C library binding to make way 
for the Red/System one

Sorry, print-line

Thanks Kaj, I forgot it was defined also in C binding.

Is there any doc how to write a test case? Or should I just hack 
it somehow?

The testing framework done by Peter WA Wood is documented here: http://static.red-lang.org/red-system-quick-test.html

You can also browse inside %red/red-system/tests/source/ to see how 
tests are done. Basically:

- language unit tests go in %tests/source/units/<feature_name>-test.reds

- compilation passing tests and compilation error tests go in %tests/source/compiler/<feature_name>-test.reds

There are two additional assertions in the float-partial branch that 
you might find useful Oldes. They aren't in the documentation yet. 
They are:


--assertF~= which takes three float!s, it compares the first two 
to be equal within a tolerance supplied as a third argument. The 
tolerance is both an absolute and relative tolerance. So, a tolerance 
of 0.01 would return true if the two floats were equal + or - minus 
0.01 or within 1 percent.

I have used a tolerance of 1e-12 in testing.

The other one is --assertF32~= which is the equivalent for float32! 
datatypes. I have used a tolerance of 1E-6 with this assertion.

I would like to write tests for enumerations: https://github.com/dockimbel/Red/pull/201

(still not finished - I must add detection if values does not exists 
already)

Kaj, compatibility can't practically be measured as a whole with 
Boolean algebra. Try fuzzy logic math :)

BrianH: that's not only fuzzy logic. That's ALL kinds of logic, not 
only fuzzy IMNSHO.

Oldes: I've emailed a skeleton test file for enum to you.