World: r3wp

and my gut says parse is worse than foreach, no?

what's your gut got to do with it?

hmm, interesting, I am quite curious, which approach would be the 
fastest one

FIND, SELECT and PICK are blazing.. foreach is a game killer. Need 
to work out a way to FIND all values

Hmm, too long :-)

to-integer to-string first second parse to-string 123.456 "."

You could tweak something like this:
    res: make block length? blk
    while [ind: find blk 23]
         [print blk append res index? ind blk: skip blk last res]
    blk: head blk
    probe res


But remember the first rule of REBOL Code Golf: parse always wins.....We're 
now just waiting for a parse guru to show us how :)

Ladislav is working on it now :)

This is the last piece to my Redis killer

parse blk [some [s: set value integer! (if value = 23 [print index? 
s])]]

not sure my version will be the smartest solution, but you can try 
how fast it is :-)

indices?-1: func [
	series [series!]
	value
	/local result
] [
	result: make series 0
	while [series: find series value] [
		append result index? series
		series: next series
	]
	result
]

indices?-2: func [
	series [series!]
	value
	/local result
] [
	result: make series 0
	parse series [

  any [1 1 value series: (append result subtract index? series 1) | 
  skip]
	]
	result
]
>> time-block [indices?-1 blk 23] 0,05
== 0.000006591796875

>> time-block [indices?-2 blk 23] 0,05
== 0.000005645751953125

(in R3)

Could you rewrite my example as indices-3? :-)

How about Rebol 2 version?

pekr, your example will be slower

since your comparison is occuring in a mezzainine

what mezzanine?

Lad, it works in R2 as well.

if value = 23

but Ladislav is doing this 

1 1 23

yes, that (in R3) means, that the times obtained are in R3

where do I get time-block from for R3?

where do I get time-block from for R3?

Write:

do http://www.fm.tul.cz/~ladislav/rebol/timblk.r

hmm, what does this mean? Is it intended? In R3:

>> exists? http://www.fm.tul.cz/~ladislav/rebol/timblk.r
== none

Hmm, my version is much slower:

indices?-3: func [
        series [block!]
        value  [integer!] 
        /local result
][
        result: make series 0
        parse series [

               any [s: set wanted integer! (if value = wanted [append result index? 
               s])]
        ]
        result
]


>> time-block [indices?-1 blk 23] 0,05
== 0.000004669189453125

>> time-block [indices?-2 blk 23] 0,05
== 0.0000039520263671875

>> time-block [indices?-3 blk 23] 0,05
== 0.0000059661865234375

what is this dirty trick good for? :-)

1 1 value ???

It's because you can't match an integer like a word

looks like foreach is still the winner (on r2)

Against a block with 100,000 integers

Lad's : 0.047
foreach: 0.044

Terry, you did not write the Foreach-base algo here, so nobody can 
compare...

1 1 value means to run the rule once and only once where value is 
the rule

A bit adapted Lad's version (does not use substraction):

indices?-4: func [
	series [series!]
	value
	/local result
] [
	result: make series 0
	parse series [
		any [series: 1 1 value (append result index? series) | skip]
	]
	result
]


>> time-block [indices?-2 blk 23] 0,05
== 0.000003936767578125

>> time-block [indices?-4 blk 23] 0,05
== 0.000003753662109375

interesting, I thought, that this modification would be slower

(index?-2 spares four assignments, while index?-4 spares two subtract 
calls)

what are your results compared to foreach?

gotta go.. bedtime in the pacific northwest

Is there any other way of how to put word in, instead of 1 1 value? 
Quote? Hmm, probably not ... I don't like the form ....

if we have 'set, we could have 'get, no?

Replacing "1 1 value" by "quote (value)" as variant 5:

indices?-5: func [
	series [series!]
	value
	/local result
] [
	result: make series 0
	parse series [

  any [series: quote (value) (append result index? series) | skip]
	]
	result
]

>> time-block [indices?-1 blk 23] 0,05
== 0.0000047607421875

>> time-block [indices?-2 blk 23] 0,05
== 0.000003936767578125

>> time-block [indices?-3 blk 23] 0,05
== 0.0000059814453125

>> time-block [indices?-4 blk 23] 0,05
== 0.00000372314453125

>> time-block [indices?-5 blk 23] 0,05
== 0.000003692626953125

Nice .. we don't have quote in r2

Wonder if that could be back ported to r2 ...

Matrix - There is no spoon ...
REBOL - There is no R2 ....

... forget R2 :-)

Brian will object anyway ...

I think that backporting parse, which is totally rewritten for R3, 
is really meaningless waste of energy ...

except for those of us using R2

Remember that we are paying R2 customers .. and R3 is not going to 
be usable for a few more years

If you would not use GUI, what exactly would be holding you back? 
You created even basic networking schemes? As for me, I miss fixed 
'call - it is still hugely crippled and absolutly useless ...

I don't do any non gui apps

Graham - that is nonsense, no? I mean - not being usable for few 
more years ... but we should move the discussion to R3, or advocacy 
...