World: r3wp

hmm.... a bit inflexible, I think. It would be nice to bypass console 
output, and store the output in memory for later scrutiny. this would 
avoid needing to popup a console to an end user.

just echo the information

before you turn on trace just do this:

echo %trace.txt

still outputs to console. I'd like to avoid that.

oh I see

I never tried it - or had need to without console output

well, I'm not sure how useful trace is to me anyway.

chris, that is nice too.

about trace, if you need a count you can probably just use the STATS 
function.

however, in a trace a call to a slow function will count the same 
as a call to a fast function.

(second stats/eval should be the number of function calls)

wow I just looked at stats on the latest view 2.7.1 and never noticed 
all the options for it before.

Yeah that is very useful Gabriele.

Paul, I don't share your concern about using ALL as a refinement 
of switch. I don't see that "killing the global ALL function" is 
a risk here. We are all aware of the danger of accidentally leaking 
words.

The advantage is we gain the freedom to use any word we like for 
the user interface.

Gabriele, slight optimization, swap these two lines:
            cases: next cases
            unless all [break]

Also, does this line:
	code: clear [ ]
mean that switch can't be used recursively ?

Chris' version looks pretty good too. (He just needs to document 
it properly.. :P)

Chris, what about [throw] ?

calling switch recursively - hmm, indeed it will be a problem. then 
i prefer chris' version which can avoid the allocation if not needed.

Yes, Chris' first line now seems clear to me. :)

Indeed I did abbreviate the function header.

Re. recursive, if you were to make block! [] instead of clear [] 
- I guess it's a difference in resultant garbage: with 'make the 
block becomes unbound when a subsequent switch is called, while with 
clear the cleared values become unbound.

do we even need 'all - I mean I think we should just make that the 
default for switch and leave select to do the light lifting.

here is a switch that defaults to 'all

switch: func [
    "Finds all choices and evaluates what follows each."
    [throw]
    value "Value to search for."
    cases [block!] "Block of cases to search."
    /default case "Default case if no others are found."
    
][  
    default: copy []
    while [cases][
        if cases: find cases value [
            append default first cases: find cases block! 
        ]
    ]
    if not empty? default [case: default]
    do case    
]

Select is by far more efficient to use for single choices.

What I found interesting with stats/evals is that "block: copy []" 
is more efficient than "block: make block []"  I would not have expected 
that.

Only issue here is that it passes over empty values.  switch/default 
[1 []][print "one"]

Try this:

switch: func [value cases /default case][
    default: make block! []
    while [cases: find/tail cases value][
        either cases: find cases block! [
            case: append default first cases
        ][break]
    ]
    do case
]

mine doesn't skip over the empty value it gives an error on it - 
which is actually useful if you ask me - I don't see any purpose 
to have an empty case passed to the switch - this way we know if 
we coded something incorrectly.

It's an issue if you're building a script incrementally and want 
an empty placeholder...

Oh I see the error you talking about

not error rather the skip

yeah that isn't good

I'd rather have an error in that case

actually yours skips over it to

no it doesn't.  I like yours Chris

That is the approach I think we should take with Switch.

I would only suggest instead of using the make block! that you use 
 'copy [].

I saw the latest 2.7.2 notes - good job everyone.  Looks like switch 
might be a dead issue for now since the previous changes look like 
they were implemented.

Yes, what is the reasoning behind using  MAKE BLOCK! []  instead 
of  COPY []  ?  It appears to me that COPY evaluates faster.

No reason really, it was the first method that came to mind.

COPY looks about 12% faster (for allocating empty blocks).

; I guess this is moot, but a slight variation of my prior 'switch:
switch: func [[throw] value cases /default case][
    default: copy [] 
    while [
        all [
            cases: find/tail cases value 
            cases: find cases block!
        ]
    ][case: append default first cases]
    do case
]

I know this rollback alot of lines, but I always marvel at  how Carl 
can reduce the size of code as he does.  He's been meditating about 
REBOL (throgh all of ancestors) for soooo long, it seems he can speak 
in rebol, "natively"  ;-)

unless is a nice addition to standard rebol, I know use it alll the 
time.

Paul, the interim releases are meant as "please test this" by all 
accounts.  IIRC view 1.3 had a few rollback based on user feedback 
of new features wreaking havoc on too many stuff.