Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

Browse thread
[Caml-list] Regular expression library: a poll on features
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2002-07-15 (15:52)
From: Xavier Leroy <xavier.leroy@i...>
Subject: [Caml-list] Re: Regular expression library: a poll on features
As promised, here is a summary of the replies I got concerning the
"feature poll" for OCaml's regexp library.

Feature 1: back-references in regexps (e.g. "([a-z]+)\1", meaning any sequence
of lowercase letters followed by another occurrence of the same

     use often                  4
     use occasionally           3
     no use                     5

Feature 2: partial string matching as per Str.string_partial_match, i.e.
the ability to recognize that a string is a prefix of a string that
match a regexp.

     has already used           0
     could use in some cases    6
     no use                     8

A few more remarks on these two features, and why I asked about them
in particular.  

Feature 1 is standard in many regexp packages because it's trivial to
implement in a backtracking regexp matcher.  However, it's essentially
impossible to implement if the regexp is compiled down to a
deterministic automata.  Thus, supporting feature 1 precludes
DFA-based implementations such as Jérôme Vouillon's RE library.

Feature 2 is unusual and I haven't heard from anyone that uses it :-)
I got two replies suggesting one plausible scenario where partial
matching could come handy: find delimiters in a piece of text that
is being read block by block.  However, I'm not sure
Str.string_partial_match is adequate here, it looks like a
"search forward for a partial match" operation is needed, which Str
doesn't provide...

It was also suggested to me that the effect of partial matching
against a regexp R can be achieved by exact matching against a regexp
R' derived from R.  This is true for "textbook regexps", e.g. if R is
"ab*c", then R' would be "epsilon|a(epsilon|b*(epsilon|c))",
but doesn't work for more complex regexps languages, especially if
back-references are supported.  (Consider R = "(a+)\1".)

Thanks for your input,

- Xavier Leroy
To unsubscribe, mail Archives:
Bug reports: FAQ:
Beginner's list: