World: r3wp

nice that is what I'm looking for.

o/p is directly known? I did not know 'self allows such functionality 
:-)

It's sweet for sure.  Another one of those hidden REBOL perks.

i don't think this is intentional, but it's something i've used quite 
a few times. basically make is returning self, whatever you make 
that be :)

>> make object! [self: "blabla"]
== "blabla"

Objects are kinda strange.  For example, if you set 'self after you 
created the context it can be referenced but remains hidden in a 
sense:

>> obj: context []
>> obj/self: "hidden"
== "hidden"
>> probe obj
make object! [
]
>> obj/self
== "hidden"

But this highly not recommened unless your aware of what your using 
your object for as self will not refer back to itself any longer.

I'd like to thank the 2.7.6 team for all the great new stuff.  In 
particular  Brian Hawley  - well done.  Kudos; the new mezz features 
are awesome.  ALSO and FIRST+ being just two of many that will make 
for more concise code.

Long Live R2.

Perhaps someone can post examples of how the new mezzanines are used 
...

ALSO;   instead of  
    tmp: first series  series: next series  tmp
   also  first series  series: next series

No tmp required,  ALSO  will return the first result of the two expressions 
 BUT in this case why?   :) 
FIRST+;   instead of the (now) useless example I just wrote;

    first+ series    ;; return value at current reference and then advance 
    reference
No tmp, no next required.  All in one expression. 


Note:  SOURCE ALSO   it's cool and will make a lot of sense when 
you see it.

Yeah the mezzanines will be very useful and should be in there just 
because of the frequency they will be used.

also: func [
    {Returns the first value, but also evaluates the second.}
    value1 [any-type!]
    value2 [any-type!]
][
    get/any 'value1
]

so, it's getting the first value .. how is it evaluating the second 
?

also 1 2    1 and 2 are evaluated by the normal sequence of getting 
arguments.   This func captures the two results (simply by having 
them as arguments) and returns the first.   Love the REBOL.  :)

ahh... deep magic

I use the following in my program:

name: any [
	also getname var: yes
	also getanothername var: no
]


if getname fails (returns none) the other function must be called, 
and a variable set to flag this. Could ofcourse be rewritten, but 
I wanted to try using also :)

ahh... deep magic

Made me think of Arthur C. Clarke's 3. law:

Any sufficiently advanced technology is indistinguishable from magic.
:-)

Nah .. it's CS Lewis, and Narnia

I wish we could do something like this:

myfunc: ['notjustanyword [word! [this that]][spec block]

That way we can only pass this or that to the function otherwise 
it generates an error

Maybe I'll add that to the wish list for R4 - lol.

is there any way to check whether the Windows clock has changed?

You can do a call to net time

Doesn't REBOL read the windows time?

Guess need more information by what you mean by changed.

if someone manipulates the clock or if it switches to daylight savings 
time, etc.

Henrik those events are written into the event log on NT platforms.

Maybe that would help to query the log.

You can see those messages by going to start -> run -> "eventvwr.msc"

Should record then in the system log section.

;Here is a handy skip function:

skip+: func [
    {Returns a series matching the skip sequence}
    series [series!] "Series to return skip values from."
    interval [integer!] "Skip interval"
    start [integer!] "Series index to start skipping from."
    /local blk][
    blk: copy []
    series: at series start
    while [not tail? series][

        if (index? series) = start [insert tail blk first series start: start 
        + interval]
        series: next series
    ]
    series: head series
    if empty? blk [return none]
    blk
]

hmm... can you give some examples of the skip+ function?

>> blk: [1 2 3 4 5 6 7 8 9 10]
== [1 2 3 4 5 6 7 8 9 10]
>> skip+ blk 2 1
== [1 3 5 7 9]

>> blk: ["paul" "john" "ringo" "george" "michael" "ted" "hans" "linda" 
"sue"]

== ["paul" "john" "ringo" "george" "michael" "ted" "hans" "linda" 
"sue"]
>> skip+ blk 3 1
== ["paul" "george" "hans"]

It allows you to start at any index position in a series and begin 
returning values that match the skip interval.

You can use EXTRACT for that:
>> extract blk 3
== ["paul" "george" "hans"]
>> extract next blk 3
== ["john" "michael" "linda"]

REBOL has so many cool functions already build in. Look here for 
them sorted by area of use:
http://www.rebol.com/docs/dictionary.html

Geomol, it reminds me that R3's help function must provide hints 
to relevant functions. I've fallen into this trap many times.

LOL geomol, I was looking all over for a function in REBOL that did 
that.

My skip function is a bit more efficient though.  Maybe we should 
replace extract with it:

>> a
== [1 2 3 4 5 6 7 8 9 10]
>> stats/evals/clear
== [2 1 2]
>> b: extract/index a 2 1
== [1 3 5 7 9]
>> stats/evals
== [218 107 33]
>> stats/evals/clear
== [219 108 34]
>> b: skip+ a 2 1
== [1 3 5 7 9]
>> stats/evals
== [187 90 39]

Looks like extract is also a bit buggy

>> a
== [1 2 3 4 5 6 7 8 9 10]
>> b: extract a 2 22
== 22
>> b: extract/index a 2 22
== [none none none none none]

But for what I'm doing I think extract will be fine since it is built 
in.  Will save me a few lines of code in my script.

I don't see a bug in any of those entries.

Probably not a bug but does we really want none to be returned?

yes, that's on purpose. in 2.7.6 you can define a different default 
value to be returned.

So how is it not a bug if you tell it to start at index 22 and there 
is no index 22 and it  is returning none?

>> a/22

sorry