World: r3wp

:-)

I usually try to take a few small steps rather than try to get the 
answer straight away.

The test data:

>> inp:  {random 2/2,2/4-6,2/33-37}

== "random 2/2,2/4-6,2/33-37"

random is sometimes a word & sometimes a number between 1 & 1000

We'll need to look for digits so :

> digit: charset [#"0" - #"9"]                   
  
== make bitset! #{

000000000000FF03000000000000000000000000000000000000000000000000

}

Does random ever have the sequence 2/number in it?

no

specific words (not many of them) on numeric alone

So what we need to look for are the patterns 2/number and 2/number-number.

on=or

or 3/number...etc or 4/ or 12/

but not on the same occasion

Let's start with 2/ and see how we get on 


>> parse/all inp [ any [copy range "2/" some digit  (print range) 
| skip ]]
2/

2/

2/

So I've found all the sequences of 2/ but didn't capture the following 
digits.

Can you see my mistake?

I see why it has done that but I dont know how to extend the copy 
to the comma except with 
to #","

Let's change the parse rule so that I capture more than just the 
2/:


>> parse/all inp [ any [copy range ["2/" some digit]  (print range) 
| skip ]]
2/2
2/4
2/33

== true

You don't need to worry about the commas. skip will take care of 
them.

so copy range has captured everything up to the point it no longer 
matches the expression in the []  a bit like a regular expression 
match.

So now I'm capturing the first number after the 2/ but not the range. 
So let's add a little more to the parse rule to capture that:


>> parse/all inp [ any [copy range ["2/" some [digit | "-"]]  (print 
range) | skip ]]                                                 
                         
2/2
2/4-6
2/33-37

== true

Yes copy captures everything that it matches.

a bit like copy thru?

You only need to use thru when you can't specify exactly what you 
want to copy.

I think of it this way:

copy variable pattern-to-copy 


copy variable pattern-to-start-copying-from thru pattern-to-stop-copying-at

So essential in cases where the middle bit is truly unpredictable

Yes

Now we can change the parse rule to work with 3/. 4 and  /12:


> parse/all inp [ any [copy range [["2/" | "3/" | "4/" | "12/"]  
some digit]  (print range) | skip ]]                             
              
2/2
2/4
2/33
== true

the 2/ part can be any number from 1 to 13

Do you want to capture all of them?

absolutely

one-to-thirteen: ["1" digit | non-zero-digit]

Then we can come up with a pattern for them:

digit opt digit "/"

could we use 1 2 digit #"/"   ?

at-most-three: [#"0" - #"3"]
non-zero-digit: [#"1" - #"9"]

one-to-thirteen: ["1" at-most-three | non-zero-digit]

I'm presuming that the only possible values are 1 to 13.

they are, but there will never be a 0/  or 22/ that we want to avoid 
in this case

Ladislav's will select values 1 to 13 from any numbers and so is 
more correct.

This is the amended rule:

>> parse/all inp [ any [copy range [[digit opt digit "/"]  some digit] 
 (print range) | skip ]]                                         
                       
2/2
2/4

2/33

== true

Oops I've lost the range again:


>> parse/all inp [ any [copy range [[digit opt digit "/"]  [some 
digit "-" some digit]]  (print range) | skip ]]                  
                             
2/4-6
2/33-37

== true

To be more lecturable, perhaps you could deal with named sub-rules

yes, we should describe the structure using named parts like:


record: [random-part whitespace repeated-part any ["," repeated-part]]

mhinson, does the structure I described correspond to what you need?

That's a good idea but I was being lazy partly because it's such 
a pain to copy and paste in AltME (it strips out all line endings).

Here's the big rule now fixed :


>> parse/all inp [ any [copy range [[digit opt digit "/"]  [some 
digit opt ["-" some digit]]]  (print range) | skip ]]            
                             
2/2
2/4-6
2/33-37
== true

Ladislav, that's my understanding

rewrote Peter's with named sub-rules

prefix: [digit opt digit]
sufix: [some digit opt ["-" some digit]]
target: [prefix #"/" sufix]

parse/all inp [any [copy range target (print range) | skip]]

Thanks, Steeve

sorry the phone rang

So now we can capture all the ranges:

>> all-ranges: copy []

== []

 >> parse/all inp [any [copy range target (insert tail all-ranges 
 range) | skip]]

== true
>> all-ranges
== ["2/2" "2/4-6" "2/33-37"]

prefix can be:
prefix: [1 2 digit]

Once we've captured all-ranges, we can process them in a second step 
: