World: r3wp

Not unless you use case/all. Did you have /case as an option to your 
function at some point?

all yeah I always forget that.

Keep thinking of like switch when I see case and I use case often.

It's more like cond from Lisp.

yeah I never used another language other than REBOL so I wouldn't 
know.

Wow. I've never heard that before.

lol - I'm just a hobbiest with REBOL.

I have no programming education.  Had to self teach me this stuff.

That is why when you use a lot of programming terms I'm lost.

I'm self-taught too, but after more than 20 years you pick up some 
stuff :)

I think that replace function is good Brian.  I would push for that 
to be a mezzanine at this point.

:-)

the reason I like it as series instead of any-block is for using 
it on long strings.

>> str: "this is just a test of replace-all"
== "this is just a test of replace-all"
>> replace-all str #"t" #"d"
== "dhis is jusd a desd of replace-all"

The case did cut it down a bit on the evals:
>> replace-all b 1 2
== [[2] [[[2]]] [2]]
>> stats/evals
== [209 100 42]

I would say that is one heck of a useful function

I've been using timblk to profile, not stats. How useful have you 
found stats to be?

its pretty useful.  Btiffin mentioned timblk also. I will have to 
look for it sometime.

replace-all: func [
    "Replaces all occurences of old value with new value"
    series "Series containing values to replace"
    oldval "Value to be replaced"
    newval "New value to replace old value"
    /local subf
    ][
        subf: func [sd][
            while [not tail? sd ][  
                case [
                    equal? first sd :oldval [poke sd 1 :newval]
                    series? first sd [subf first sd]
                ]
                sd: next sd
            ]
        ]
        subf series
        series
    ]

same function just commented a bit and changed sub-ic to just subf 
meaning subfunction

catch throw-on-error?

Add the [series!] type check to the series parameter of the outer 
function and you'll be set.

oh yeah

catch throw-on-error
 What do you mean?

Should it throw errors to a catch so that it doesn't expose the lower 
code?

not sure how that would behave in this case

You aren't doing anything in the inner code that could generate an 
error, so no need.

If were sure that all the values that it traverses are comptible 
then I agree.  In fact I don't think we need one until it becomes 
known as a problem.

The only problem would be if your blocks have cyclic references and 
you get stack overflow. I'm not sure you can catch that.

replace-all: func [
    "Replaces all occurences of old value with new value"
    series [series!] "Series containing values to replace"
    oldval [any-type!] "Value to be replaced"
    newval [any-type!] "New value to replace old value"
    /local subf
    ][
        subf: func [sd][
            while [not tail? sd ][  
                case [
                    equal? first sd :oldval [poke sd 1 :newval]
                    series? first sd [subf first sd]
                ]
                sd: next sd
            ]
        ]
        subf series
        series
    ]

Don't put [any-type!]. The only difference between that and no type 
spec at all is that your function would be able to accept unset! 
values, and that would require other changes to your code to work 
properly.

here this is better to read:

ahhh good point.

replace-all: func [
    "Replaces all occurences of old value with new value"
    series [series!] "Series containing values to replace"
    old-value  "Value to be replaced"
    new-value  "New value to replace old value"
    /local subf
    ][
        subf: func [sd][
            while [not tail? sd ][  
                case [

                    equal? first sd :old-value [poke sd 1 :new-value]
                    series? first sd [subf first sd]
                ]
                sd: next sd
            ]
        ]
        subf series
        series
    ]

I changed newval to new-value and oldval to old-value

That is the REBOL way :)

hehe - looks good.

In general, I find that it is a good idea to let unset! values be 
erroneous, rather than changing your code to accept them. That makes 
it easier to make a clear distinction between non-values that are 
erroneous (unset!) and non-values that may not be erroneous (none!).

good tip

Is it a good practice to unset series within functions if the series 
is an argument to the function?  Not sure how the garbage handler 
in REBOL works or if it sees it as garbage until the next function 
call.

In other words if i pass a massive series of data as an argument 
to the function should I at the end of the function unset that argument?

I wish Carl would give us pointers on when to use unset function 
and how to optimize our use of the memory space and other performance 
tips.

That was something I brought up during R3 development. R3 series 
don't retain references between calls, R2 series do. In general this 
is not a problem, but if the extra references are becoming a memory 
leak, change this:
    series
to this:
    also series series: none

what is also?

You almost never need to use the UNSET function; setting to none 
is usually sufficient.

interesting.

ALSO is one of the R3 backports in 2.7.6. Here:
also: func [
    {Returns the first value, but also evaluates the second.}
    value1 [any-type!]
    value2 [any-type!]
][
    get/any 'value1
]

ok I remember some discussion about that.

This is one of those cases where unset! wouldn't be an error, so 
the code handles it.

It would be any problem? wouldn't the get/any cause a problem if 
it encountered the unset!?