World: r3wp

I don't know, as for me, I just wanted to|thru [a | b | c] :-)

I would let others more skilled parse gurus to raise their wishes 
...

petr, i didn't say r3 won't improve on parse, i said that the first 
release may not have the new features.

we won't stop at 3.0... there will be a 3.1 and so on... at least 
we hope so :)

(lost my connection yesterday night and the message i was typing...)

parsing utf-8 in r2 is easy. utf-16 and utf-32 are less confortable 
but should be easy too.

of course with r3 it's much easier because - i guess - you can just 
parse the unicode! string.

Is it possible to combine two bitset!s?

using  'union

great, thanks!

Is there some way to make this work: parse "aaa" [some "a" "a"] or 
PARSE just don't work this way?

What do you mean?
>> parse "aaa" [some "a"]
== true

Why the second "a"?

It may seem strange I know, but this is automaticaly created rule

Parsing for [some "a" "a"] will return false, because you've already 
parsed past the "a"s.

OK I need to find some other way :) Is it possible to go back in 
parse? -1 skip doesn't seem to work.

I was thinking the same. I seem to remember, that at some time (some 
version of REBOL), -1 skip did work!? Hmm...

Wasn't it just proposed for R3?

A clumsy way of doing it:
>> parse "aaa" [some "a" p: (p: skip p -1) :p "a"]
== true

OK thanks, that may help

That's not so clumsy. You want to backtrack and that's what you're 
doing.

obviously you could use (p: back p)

Even better. Thanks Anton. Seems that "-1 skip" should not be that 
hard to implement

parse "aaa" [some [p: "a"] :p "a"]

I think this needs (p: back p) before :p.

Not in my version. The p is set before the position advances past 
the "a", so it is already back.

The p is reset before "a" is consumed - that is why I put [p: "a"] 
in [].

So why it does return 'false here? p is empty on :p.

Interesting. It seems to be setting the last p before it fails on 
the last iteration of "a".

Clearly I need a temporary.

parse "aaa" [some [p1: "a" (p2: :p1)] :p2 "a"]

I have done this sort of thing before.

temporary, or step back

A temporary will work better with parts of unknown size, and be faster 
too.

OK

Still, you might want to apply rewrite rules to your generated parse 
rules - that code seems a little sloppy.

Peephole fixing?

rewrite rules?

that you will not have [some "a" "a"] but just [some "a"]

Well, I'm not exactly sure if that's possible, I have to do some 
tests

By rewrite rules, I mean something like what Gabriele came up with 
for the rebcode assembler a while ago. Since I helped refine his 
work, I may still have a copy somewhere. I'll take a look.

I'm not sure I helped with this one, now that I think of it. It's 
one of his literate programming projects, here:
http://www.colellachiara.com/soft/Misc/
Look for rewrite.*

that one is different from the one in rebcode, but the principle 
is about the same.

OK I'll check it, thanks

is it possible to convert bitset! back to something readable?

Define readable! ;-) Maybe you could use a combination of to-string, 
to-binary, debase and things like that.

if i do (a: charset "abc") i want to do also (decharset a) to get 
"abc" :) that's readable ;)

loop thru all possible chars, print matches ;)

yes, but that's really not the fastet way :)

Rebolek, use my hokus-pokus function:

hokus-pokus: func [
	value
	/local a out
][
	either bitset? value [
		a: enbase/base to-binary value 2
		out: copy ""
		forall a [
			if a/1 = #"1" [append out to-char (index? a) - 4]
		]
		out
	][
		42
	]
]

>> a: charset "abc"
>> hokus-pokus a
== "abc"

bitset-to-string: func [b [bitset!] /local s] [
    s: copy ""
    repeat x 256 [
        x: to-char x - 1
        if find b x [append s x]
    ]
    s
]