World: r3wp

BrianH, if you feel those mezzanine changes are necessary then I'm 
all in favor of it.

It's already done for REWORD, which is blocked because of critical 
map! bugs. An easy addition to EXTRACT and tweak to COLLECT.

EXTRACT and COLLECT enhancements submitted.

New discovery: You can assign an op! to another word and it still 
works as an op!, infix style. Want to rename your ops? Now you can 
:)
>> &: :and
== op!
>> false & true
== false

New discovery: APPLY treats 'a and :a parameters like a, ignoring 
the special treatment that specifying parameters that way would otherwise 
give you. This is a great thing: Now you can write functions that 
function values without the code injection risk that those special 
parameters have.

Janko, to reanswer your question: "will R3 have a way to define custom 
infix words?"

Yes, at least custom words to refer to existing infix functions for 
now. In theory this new behavior could be used to make new op! functions, 
but there will likely not be a facility to do so until the plugin 
model is finalized, and the redirect-to-an-action functionality may 
remain even then.

We can already rename our ops in 2.7.6

Yup. And then are they still infix?

I don't think so.  Let me check.

No, they are not.

They are in R3. My guess is that R2's DO special-cased the standard 
op! words, while R3 goes off the op! type.

BrianH: interesting discovery

I've wanted this for YEARS!

why?

General principle, mostly, but also localization or other-language 
emulation of operators. Plus it makes user-defined operators possible, 
in theory.

Yeah I have never seen a need myself but its cool none the less. 
 Rather have a feature than not have it.

The APPLY discovery is bigger news, since that code injection trick 
is a real concern.

What does APPLY do?

>> help apply
USAGE:
        APPLY func block /only

DESCRIPTION:
        Apply a function to a reduced block of arguments.
        APPLY is a native value.

ARGUMENTS:
        func -- Function to apply (any-function!)

        block -- Block of args, reduced first (unless /only) (block!)

REFINEMENTS:
        /only -- Use arg values as-is, do not reduce the block

Not sure I get it.  Give me an example.

APPLY is good for wrapper functions, and now for using function values. 
From COLLECT:
    output: apply :insert [output :value none none only]
From USE:
    apply make closure! reduce [to block! vars copy/deep body] []
From ACCUMULATE:
    value: apply :fn [:value series/1]

>> a: func [b c][print b + c]
== make function! [[b c][print b + c]]

>> apply a [2 3]
** Script error: a is missing its c ar

My error is because I followed the help to the letter.

This is why I decided not to participate in the documenation of R3 
- because some of the help just doesn't make sense to me.

No, your error is that you didn't pass a function, you passed the 
name of a function, without expecting it to evaluate. Try this:
    apply :a [2 3]

Apply takes a function, not a word. The func parameter is not a 'func 
lit-word! parameter.

But that isn't how the help stated it.  If it wanted me to pass the 
spec to the appy function it should have said so.

But it is still a function

No, parameters evaluate unless they are specified with lit-words 
or get-words in REBOL. That is how all REBOL functions work.

Why do we need Apply?

Low-level code, special tricks, wrapper functions, safe evaluation, 
passing along refinements, ...

Ok your right Brian, the help is perfect.

I haven't been programming in REBOL long enough to understand this 
stuff.

I'll put in a ticket to change the help string from "Function to 
apply" to "Function value to apply", just in case.

It might even be accepted :)

Done.

huh.... I see rebol has many intereting words that I haven't even 
known about what even thought what they alow me to do .. like these 
that you mention apply and collect

Brian, I'm not sure that value is a good term either - maybe others 
can comment.  I like to say spec.  As that makes more sense to me. 
 Newbies might think value means argument.  No matter how silly these 
 things seem - not everyone that is going to learn REBOL will have 
a programming background.

specification rather than spec.

But you don't pass the function spec, you pass the function value. 
The function spec is the block with the parameters, types and doc 
strings. The function value is the value that gets assigned to the 
word that is used as the name of the function, it any.

it -> if

The function value is like :add, the function spec is (in R2) third 
:add or (in R3) spec-of :add.
>> print mold third :add
[
    "Returns the result of adding two values."
    value1 [number! pair! char! money! date! time! tuple!]
    value2 [number! pair! char! money! date! time! tuple!]
]

Brian .. some most certanly a crazy question ... is there a way you 
could walk/execute a block of code in steps ... this is probably 
possible (if they take no arguments)  [ func-1 func-2 func-3 ] ... 
but is there some "magic" way to execute make func consume their 
arguments, like this >> b: [ print "hello" add 4 6 ]<< and >>do get-expr 
b 1<< would print "hello" and >>do get-expr b 2<< would calcualate 
10 ... I know this is probably not even remotely possible

Yes, DO/next. But it doesn't work in R3 yet, just R2. That is a bug, 
btw.

what is a bug?

DO/next not working in R3. It's not an intentional change.

hm.. :) there really is do/next :)) awesome

aha... I was scared do/next is a bug :)

DO was rewritten in R3, and not all of the old behavior is implemented 
yet. Though there are some intentional differences.

LOAD was rewritten too, as a mezzanine, by me. There is still some 
missing functionality, and some fixes to bugs in R2's LOAD.