World: r3wp

For those of Scottish descent, does this work for you?


fix-scots: func [ result /local rule][

    rule: [ thru " Mc" mark: skip ( uppercase/part skip result -1 + index? 
    mark 1) ]
    parse result [ some rule ]
    result
]

Or, are there some other funny capitalization rules I need to do?

Mc and Mac.

uh !? what are those skips ???

But I see Macdonald ... and not MacDonald ..

skip not necessary ..

how do you decided whether it's MacDonald or Macdonald??

indeed :)

I'd say MacDonald, but I'm not one, so don't know.

One side of my family have the convenient Ross, the other dropped 
the Mc to leave Gill (back in time somewhere)

They call it a big Mac not a big Mc ... odd

when it's McDonalds

I guess they're being inclusive

As far as I'm aware, Mc and Mac are interchangeable.

In legal documents? Interesting.

I'm grabbing my phone book ....

My family switched away from the Scottish spelling too, back in the 
19th century when that branch came to the US.

Didn't say that, just usage.

Each family picks one spelling and sticks with it nowadays, mostly 
because of those legal documents.

Yep, my phone book has the Macleans between the Mcleans

so the alphabetical ordering system they're using treats mc and mac 
the same

B: from what name?

Phone book sorting - that's really complex :(

Halle

Sounds nordic...

To Hawley, the English spelling. To reduce prejudice in the US.

It's old Celtic.

Apple MacIntosh ??

I think I'll skip Macs

As opposed to MacKintosh.

you can't guess, you need the list of all clans :)

hi, it's me again with parse problems...  I need this concretely 
to parse out web-page meta tags.. but I distilled the problem out 
of it to a minimal example..

doc1: "start A 1 end start B 2 end"  how can you get value of  2 
out

It works with a because it's first , but becasuse it enters the "parse" 
with it and then doesn't match it doesn't again test the B 

>> parse doc1 [ "start" "A" copy R to "end" (print R) to end ]
 1
== true
>> parse doc1 [ "start" "B" copy R to "end" (print R) to end ]
== false

I thought it will recheck if I put it into something like SOME [ 
] but it doesn't 


parse doc1 [ SOME [ "start" "B" copy R to "end" (print R) to end 
] ]

Maybe ? parse/all doc1 [ thru "B" copy number to "end" (print number) 
]
But I'm beginning with parse, so I'm not an expert

This would work in this case but I need to get "2" only if sequence 
before it is exactly previous two "start" "B" XX "end" ...  there 
can be "B" in other places of the string and it musn't take that 
(I am used on using thru and to too but I musn't use them in this 
case for this reason as it might just skip to some "B"

>> doc1: "start A 1 end xyz B 2 end" ;; in this case it must not 
take 2
== "start A 1 end xyz B 2 end"

>> parse doc1 [ "start" thru "B" copy R to "end" (print R) to end 
] ;; but it will that's why I can't u
se to\thru
 2
== true

some ["start" ["A" | "B"] copy R to "end" "end"]

ups ... my example above is wrong .. just a sec

no, hang on...

Anton this would  return me 1 probably ?

(this is the right example .. I forgot to use thru above so second 
wouldn't pass anyway... but result is the same)

>> doc1: "start A 1 end start B 2 end"
== "start A 1 end start B 2 end"

>> parse doc1 [ thru "start" "A" copy R to "end" (print R) to end 
]
 1
== true

>> parse doc1 [ thru "start" "B" copy R to "end" (print R) to end 
]
== false

>> parse doc1 [ SOME [ thru "start" "B" copy R to "end" (print R) 
to end ] ]
== false

Is there anything expected between "start" and "A", for instance 
?

I know how to solve this by making it less robust (in this case relying 
that there is only one space between) but this doesn't solve my problem 
well 

>> parse doc1 [ thru "start B" copy R to "end" (print R) to end ]
 2
== true

No need for that.

1 or more spaces (to your question)

parse doc1 [some [thru "start" ["A" | "B"] copy R to "end" (?? R) 
"end"]]

hm.. just a sec so I try few things

PARSE without the /ALL refinement handles any amount of whitespace. 
(You will probably end up using parse/all, though. I usually do when 
parsing HTML.)