World: r3wp

Be sure to change your oldval and newval references to get-words 
for safety.

Not sure I follow you.

Oh so it doesn't evaluate them you mean.

either equal? first sd :oldval [
                    poke sd 1 :newval

Yeah good point

Did i spark your interest for changing the replace function?

If so I suggest you keep the replace function and make this an entirely 
different replace function.  Call it replace-deep if you like.

Then just cut out out the /all from your current replace function 
and leave as is.

The reason is that I believe this will be more tasking on the stats/evals 
then replace is by far.

By the way that recursion method with the function inside the function 
is the only way I found to get round most of those stack errors you 
mentioned.

Have you seen the replace function? We are getting to the point of 
diminishing returns on new features - too much complexity overhead. 
As it is, we are going to have to use APPLY in the R3 version just 
to add another option.

No I haven't really paid much attention to it.  i know there was 
some discussion on the 2.7.6 discussions but i haven't followed R3 
development much at all.

Do source replace - it's a good way to learn some interesting optimization 
techniques.

is it the same in 2.7.6 as it is in 2.7.5?  I'm currently using 2.7.5.

No, it really isn't. The 2.7.6 REPLACE was one of the backports, 
as was EXTRACT.

Extract is in 2.7.5 also which is the one I was using.  Maybe that 
is why we are on different pages on that issue.

I'll check them out later.

I didn't realize that you weren't using 2.7.6. I wrote REPLACE and 
EXTRACT in that release.

oh - lol.

replace-all: func [series oldval newval /local sub-ic][
        sub-ic: func [sd][
            while [not tail? sd ][  
                either equal? first sd :oldval [
                    poke sd 1 :newval
                ][
                    if series? first sd [sub-ic first sd]
                ]
                sd: next sd
            ]
        ]
        sub-ic series
        series
    ]

>> replace-all b 2 1
== [[1] [[[1]]] [1]]
>> stats/evals
== [219 105 47]

Do you really want to do this:
>> replace-all ["1"] 1 2
== ["2"]
Otherwise, change series? to any-block?

Actually, that is exactly what I want

replace-all: func [series oldval newval /local sub-ic][
        sub-ic: func [sd][
            while [not tail? sd ][  
                case [
                    equal? first sd :oldval [poke sd 1 :newval]
                    series? first sd [sub-ic first sd]
                ]
                sd: next sd
            ]
        ]
        sub-ic series
        series
    ]

CASE is faster than 2 comparisons with EITHER or IF.

I recall you saying that before I never really checked it out.

I profile code patterns to see which is faster.

I think your case is messed up

I think I had that if for a reason but not sure why

in the case of mine both conditions will not be true whereas in your 
case arrangment both can can't they?

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