Builtin regex (Was: How to complex switch?)

[Robert Clipsham]

On 13/05/2011 16:12, Dmitry Olshansky wrote:
>> Regex is ugly, impossible to maintain/debug and slow for anything
>> mildly complicated - a handwritten parser is magnitudes faster, and
>> easy to understand, maintain and debug. If it's simple, you may as
>> well write a couple of extra lines and have it be a lot faster.
>>
>
> Handwritten parser is faster, but hard to get right, port or maintain.
> Also handwritten parser has almost zero flexibility - patching it to
> accommodate new kinds of input is PITA.

When you've written a couple it doesn't take much to get it right in my 
experience. I don't find them hard to maintain personally, I guess that 
comes from experience though. What do you mean port?

As for patching for new input, that's a doddle if it's well written. 
Changing a regex on the other hand... It's generally easier to write it 
from scratch than decipher a current one.

> Regexes on the other hand are widely known DSL for pattern matching,
> which IMO easier to get right, port across languages and platforms (with
> caveats). Flexibility - regex engines in a way are just simple parser
> generators with some bells and whistles. And BTW they could be quite
> fast (depending on the use case, of course).

Of course, I don't feel that grants them a place in the language though. 
Particularly with the likes of octal! - it can quite easily be in a 
library and work just as well.

>> Just my opinion of course, I know you're bound to disagree :>
>>
>
> Probably you never faced problems like "get me some info from these
> <enter your gazillon number> simple reports/emails/etc." All things that
> don't follow some formal language enjoy flexibility on the parser side.
> E.g. you can patch together through try/trial cycle a couple of
> aproximate regexes and have very reasonable results in no time.

I have, and I use regex for it. Those kinda things just need a quick 
hack, and that's how I treat regex. If I'm doing anything that's getting 
used in production code/anything that isn't intended to be a hack I 
write a proper parser.

> The real pitfall of regexes vs handcrafted parsers is that they can't
> match important classes of problems like: "the innermost parenthesized
> expression in a given string" and such.

KennyTM~ gave you regex for that, providing you mean outermost - 
\((.+)\) will do it. Somewhere inbetween is harder, but doable if I 
recall correctly. But yes, there is a whole class of problems regex 
can't solve. The real pitfall for me is how difficult it is to 
decypher/debug.

-- 
Robert
http://octarineparrot.com/