World: r3wp

conditionally

saw that in one forth book.

If there are no other comments or suggestions, I'll submit it as 
worded above.

I am ok with that. after thinking about prolog&icon withthe if too.

Go.

yes

I didn't do a really useful example, just one to demonstrate the 
current way of faking the behavior.
Example:  [if (test) | ...]
Fix:  [(unless test [dummy: [end skip]]) dummy | ...]

On a (slightly) different note, has anyone tried to implement incremental 
parsing with parse? Last time I tried something like continuations, 
but there must be a better way...

For instance, can you put a wait in a parse paren?

Interesting idea. I guess that would work. but not with async.

for small things i would just reparse the whole thing.

See, this is why I wanted that if clause. It's so easy to mess up 
the workaround.
Fix:  [(dummy: unless test [[end skip]]) dummy | ...]

what i would like is in incremental parse as base for multitasking.

I was thinking about parsing data larger than available memory, or 
coming over a slow link.

Something like do/next for parse.

Or beeing interactive, where the next things depend on what you reply.

but i know no good way with parse only.

f: open/direct file
a: copy/part f 4096

parse a [some [rule1 | rule2 | b: if (if a: copy/part f 4096 [b: 
join b a]) :b]]

With the IF workaround applied, if you can.

Well, I submitted the entry when you all said it was OK (I forgot 
to mention). Now we get to see how it all turns out. I like RAMBO 
much more than feedback - more public.

Later all!

Keep us informed on the outcome :)

btw, my compile-rules.r implements IF (i don't recall if exactly 
as noted above, but i think so, or very close). i had a rep with 
this and other things too.

http://www.compkarori.com/vanilla/display/TO, THRU And NOT PARSE Rules 
implements IF too, but using IF [...] instead of IF (...) , which 
is the only difference as far as I can tell

Gabriele, I recall that it didn't work the same, but have no way 
of checking that right now because I couldn't find your compile-rules.r 
on rebol.org and you didn't provide a link just now.

it's different, as i made it as:

| 'if set val1 paren!                        ; NEW: apply rule only 
if condition is true
            element

      | 'either set val1 paren!                    ; NEW: choose rule based 
      on condition
            element
            element

i think there are pros and cons to both approachs.

i admit i haven't used if and either much though, what i used a lot 
was DO.

I prefer the continue-if-true version. I particularly like that there 
is a workaround now that the backtrack-through-paren bug has been 
fixed since I first suggested an IF clause.

BrianH: see the above link, it is an IF as you proposed, except that 
it uses a block instead of paren!, because that was simpler to implement, 
but it doesn't matter much, can be transformed

How do get parse out ^?

>> caret: charset [ #"\^" ]
** Syntax Error: Missing " at caret: charset [ #"\^" ]
** Where: halt-view
** Near: caret: charset #"a"

^^

oh :(

I thought \ was the escape char.

I like it. easier to include javascript in strings, no need to escape 
its escapes.

What do you like?

that rebol uses a different escape-char.

ok

>> caret: charset [ #"^^" ]
== make bitset! #{
0000000000000000000000400000000000000000000000000000000000000000
}

>> obx: {OBX|1|ST|Hb^ Hb:^L||135|g/L|120 - 155|N|||F^/}
== "OBX|1|ST|Hb Hb:^L||135|g/L|120 - 155|N|||F^/"

>> parse obx [ "OBX" "|" digits "|" "ST" "|" thru caret to end ]
** Script Error: Invalid argument: make bitset! #{
0000000000000000000000400000000000000000000000000000000000000000
}
** Where: halt-view

** Near: parse obx ["OBX" "|" digits "|" "ST" "|" thru caret to end]
>>

Is that with the caret as an escape char, or as a value?

that is thru with a charset. any caret

no, grrr, lack of smarter thru is annoying.

Because it looks like the carets in your data are registering as 
escape characters. That ^H is registering as a backspace character, 
not the sequence "^H".

any non-caret caret  ;?

It's ^spaceH

ok, parse enhancement proposal .. allow one to change the escape 
character.