P
6277

Such a change would take some serious testing too... because -N can be applied to many actions. For example, what if someone types -2 "a" ?

It may be possible to restrict it, but it means each action must check for the possibility... another IF.

P
6261

P
6256

its the very first R3 specific script to be uploaded in history :-)

http://www.rebol.org/view-script.r?script=bnf-compiler.r

P
6255

I'm currently building a C compiler using R3 and it just so happens that I need a negative skip right now in the pre-processor!

funny that you posted this idea today.

P
6244

its just a simpler way of doing:

[ here: (skip here -2) :here ]

and would make reverse parsing dead easy... skip backwards until a (forward) pattern is found.

P
6243

P
6241

P
6231

For example: [to ":" skip -2 "ab"]

Right now, skip negative is an error.

P
5837

>> test: ["123"] parse "123" [test] == true

>> limit: ["123"] parse "123" [limit] ** Script error: PARSE - invalid rule or usage of rule: end! ** Where: parse ** Near: parse "123" [limit]

P
5674

http://freebol.org/media/shared/whitespace.r

P
5660

http://hostilefork.com/shared/rebol/whitespace.r

Haven't tested it much, it was written rather quickly. Because, well, c'mon. It's a joke.

Yet at the same time, I think putting a bit of effort into this could be useful. It tells a story about how to implement a CS 201 assignment in a new, different way. You've got an uphill battle because you have to tell the story of "Why Rebol, not Haskell?" But I think it's a story that can be told.

Here's the output on the sample input, for anyone not feeling like running it:

http://hostilefork.com/shared/rebol/whitespace-output.txt

What I'd really like to do is have the result of the parse be a nice clean dialect. I'm thinking about that. But using the parse dialect as the VM is a good demo.

H
5409

P
5408

P
5407

Nonetheless, I'll check again in case they've made new suggestions this year.

P
5406

P
5405

P
5404

P
5403

And, actually, I should comment... I had to do some work on a parsing script recently, but R3 PARSE needs some of these changes before it's works well enough.

Also, features like TO multiple can *save* a large amount of coding time (and thought), even though they will be quite CPU intensive.

P
5399

P
5397

P
5396

P
5394

P
5393

P
5392

I remember BrianH posted a list... but I've blanked out about where it is. I also know of Gabriele's and Ladislav's requests from before. I also have my personal favorites that I need.

P
4901

P
4898

P
4896

As for more complex CSV, the DECODE and ENCODE approach could work, but you would need DECODE-CSV and ENCODE-CSV wrapper funcs so we can specify which CSV variant we want to encode or decode, since there is no flag in the data format itself that says which variant is being used.

An alternative would be to add a /with opts option to ENCODE and DECODE that would let you pass along an object-spec-style block of options to the encoder or decoder. Not all en/decoders would need such options, but having the ability would let more complex en/decoders be implemented.

I prefer the second option, but that depends on feasibility. I'm not sure which is more difficult: Passing options to en/decoders, or having multiple codecs that map to the same file type loaded at the same time. The latter may work if only one of the choices registers a file extension for LOAD, but have others loaded and used explicitly.

P
4894

P
4893

P
4892

For complicated CSV, we'll need a decoder, and then just use DECODE 'csv data. In fact, someone can write an encoder too: ENCODE 'csv block-of-data. That way we keep it consistent with how R3 decodes and encodes things.

P
4891

P
4890

P
4876

P
4875

According to http://tools.ietf.org/html/rfc4180 : >> parse {"hello""world^/",a} "," == [{hello"world^/} "a"] >> length? parse {"hello""world^/",a} "," == 2

It's a quick fix, and should allow more data to be gotten with simple parse.

P
4874

P
4873

P
4855

P
4843

P
3355

P
3354

P
3346

>> parse/all series [count [copy xxx size skip (print mold xxx)]] [1] [2] [3] == false

>> series: "123" == "123"

>> parse/all series [count [copy xxx size skip (print mold xxx)]] "1" "2" "3" == true

>> count == 5

>> size == 1

P
3345

>> parse first [(1 2 3 4 5 6)] [some [copy p 2 skip (print mold p)]] [1 2] [3 4] [5 6] == true

P
3344

P
3342

P
3341

P
3276

P
2528

P
385