World: r3wp

brian, is assert faster than its equivalent  [any all] combination 
?

Thank you Maxim and Brian.  I enjoy your help!

ASSERT is as fast as ANY, but faster once you add the error generation 
code to the ANY statement. ASSERT/type is *much* faster than ANY.

cool

ASSERT is a great way to integrate your tests right into your code, 
making TDD irrelevant. The module system uses ASSERT a lot to catch 
attempts to hack the security.

For now, at least. We may switch to explicit error generation in 
some cases, for more informative errors.

In R2 I'm trying to define a function that will return back 120% 
of some values similar to this:

scale: func [ val ][ val * 1.2 ]  <-- this works but returns a decimal 
-- I'd like it to return integer, so I tried

scale: func [ val ][ to-integer reduce [ val * 1.2 ]]  <-- doesn't 
work  -- what am I doing wrong

remove the [ ]

and the reduce

it needs parens

to-integer (val * 1.2)

you sure?  '* should take precedence

scale: func [ val ] [ to-integer val * 1.2 ]

AS I read it, it looks like, take the integer of val, then multipy 
by 1.2, which in my mind would return a decimal, but that is not 
happening that way right?

Graham, yes your right..

mine?

yes

* has higher precedence than 'to-integer so it gets used first

Thank you for that clarification!

Pat, there is only one precedence rule in rebol expressions:

 ops resolve left to right, THEN functions are interpreted in argument 
 grabing order.

So any ops (i guessing that is any math expression) is evaled first 
left to right, then however the arguments are evaluated -- right?

which is annoying when using comparison ops with functions... ex:
if length? val = 3  ; wrong... 

val=3 ; true
length? true ; error

to-integer multiply 10 1.125 => 11

so you always have to put the ops BEFORE comparing to a function...

if 3 = length? val

length? equal? 3 val

so THAT is why I sometimes see some IF statements like that!!!

yes

easier to use the function equivalents

What do you mean GrahamC?

equal? instead of =

add instead of +
multiply instead of *

ahhh I see

if you want to use ops the way your head probably thinks about logic, 
you'll need to use parens which add a (minuscule) slowdown... really 
its a very small hit.

IF (length? val) > 3 

but this can be recoded as:

IF 3 < length? val

the problem with using funcs is that they extremely confusing to 
read.  so they are very rarely used.

Very good to know!

and for the record... this was wrong...

length? equal? 3 val

it should be

equal? length? val 3

that reads better :)

the problem is that 3 and equal? go together... obviously I chose 
to order them this way to prove the point... but on any expression 
with more than 2 or 3 ops... function use becomes so complex to decipher 
that its worth it, just adding parens.


I did tests a while back and enclosing things in parens was usually 
practically invisible in loops... just a single path evaluation (like 
pair/x) takes up much more time IIRC.

Got a simple question:


I defined a function called pref.  Its purpose is to simply print 
a precise time and value (which could be one of several values), 
but it is not doing what I expect:

pref:	func [value][print [now/time/precise "-->" value]]

pref	["Your current directory is" what-dir]    ; <-- wanted hh:mm:ss:xxx 
--> Your current directory is ...


but instead I got this:   15:04:43.968 --> Your current directory 
is what-dir


the function did evaluate the now/time/precise correctly, but did 
not evaluate the what-dir.  What can I do to get it to resolve all 
passed variables?

pref	reduce  ["Your current directory is" what-dir]

oh yes,  reduce!!!  Thank you

I don't understand this situation:
>> help same?
USAGE:
        SAME? value1 value2

DESCRIPTION:
        Returns TRUE if the values are identical.
        SAME? is a native value.

ARGUMENTS:
        value1 (any-type!)
        value2 (any-type!)

s1: "series"
s2: copy s1
same? s1 s2
== false


The two values are two separate yet identical values.  Does identical 
mean the same reference ie the same memory location in rebol or am 
I not understanding what identical means?

Should the description read like this:

DESCRIPTION:
        Returns TRUE if the values are identical references.

or 
        Returns TRUE if the values are identical objects.

It returns true if the values in the value slots have exactly the 
same bits. For immediate values (chars, numbers, typesets, ...), 
that is exact equality. For reference values (strings, blocks, objects, 
bitsets, ...) that is exactly the same reference. So that means that 
SAME? 1 1 returns true even though those integers are in different 
value slots.

Since that is two different forms of equality, we had to use the 
more general term "identical". We can't test reference equality on 
immediate values because REBOL is a pass-by-value language, and only 
passes references when that is the value, as it is for reference 
types.

Thank you Brian!  That helps me understand it a little more.

In R3, reference types are the types that aren't in the immediate! 
typeset (which is just documentation):
>> print mold immediate!

make typeset! [none! logic! integer! decimal! percent! money! char! 
pair! tuple!

 time! date! datatype! typeset! word! set-word! get-word! lit-word! 
 refinement!
issue! event!]

That reminds me, I should check whether the immediate! typeset was 
added to R2/Forward and R2 yet.

In R2 it would not have all the same types, of course, but it should 
be a strict subset.

Hi,so i am quite new to the rebol community and have been assigned 
a project to work on.So to be frank i started reading rebol 2 days 
ago and i am quite confused since i worked with c++ before that.I 
am stuck at flow control and operators(sad i know).So basicaly i 
thought of when i moved from delphi to c++,basically if one of you 
guys can provide me with a rebol version of this small program i 
whipped up(flow control number check-the basics) it would be of great 
help to me,so here is my program and thanks in advance.
    

It inputs an integer number n and outputs the sum: 1+22+32+...+n2.I 
use input validation for n to be positive.
#include <iostream>
using namespace std;
    
int main()
{
     int n;
     cin >> n;
     if (n < 0) return 1;
     int sum = 0;
     int i = 0;
     while (i <= n) sum += i*i;
     cout << sum;
     return 0;
}

Welcome!
I've posted one possible approach on REBOLforum:

   http://www.rebolforum.com/index.cgi?f=printtopic&topicnumber=46