Version française
Home     About     Download     Resources     Contact us    
Browse thread
Thread safe Str
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Martin Jambon <martin_jambon@e...>
Subject: Re: [Caml-list] Thread safe Str
On 12 Jan 2005, skaller wrote:

> On Wed, 2005-01-12 at 07:53, Martin Jambon wrote:
> > On 11 Jan 2005, skaller wrote:
>
> > > See the ulex package for a model. The problem with micmatch
> > > is precisely that it does use Str.
> >
> > It uses either Str or PCRE.
>
> > You can also integrate ulex by yourself if it is possible.
>
> I'm not sure .. ulex doesn't use NFA's does it?
> AFIAK it doesn't support captures.
>
> The problem with micmatch is that it probably doesn't do what
> can be done with a system supported in the core language,
> linear matching over all cases. Felix does do it: in this code
>
> regmatch .. with
> | re1 => ..
> | re2 => ..
> | re3 =>..
> endmatch
>
> the input characters (from ...) are read exactly once,
> not only is there no backtracking, since a DFA is used,
> but it isn't a sequence of comparisons (it's a DFA based
> tokeniser, the token selecting the RHS expression).
>
> I would guess micmatch does not support that, although
> it probably could.

Sorry, I don't know the details of what can be done with DFA or NFA.
The idea of micmatch is to be compatible with the behavior of the regular
match...with, which allows us to mix both forms of pattern matching
(returning the first match, not the longest match).

The following returns `Case1:
match "abcde", 1 with
   RE "abc", 1 -> `Case1
 | RE "abcd", _ -> `Case2

And the following simplified code still returns `Case1:
match "abcde" with
   RE "abc" -> `Case1
 | RE "abcd" -> `Case2

And similarly this returns "abc":
match "abcde" with
   RE ("abc" | "abcd" as x) -> x



I could implement the following syntax:
match subj with
  RE (re1 as x1 => `Case1 x1 as y) | (re2 as x2 => `Case2 x2 as y) -> y

And the simplified forms:
match subj with
  RE (re1 => `Case1 as y) | (re2 => `Case2 as y) -> y

match subj with
  RE (re1 => f1 ()) | (re2 => f2 ()) -> ()

We could then do sophisticated things like that:
match subj with
    RE ... ((re1 => f1 ()) | (re2 => raise Try_next_please)) ...  -> ...
  | ... (* next *) -> ...

but I don't know if these additions would be a good thing.


Martin

--
Martin Jambon, PhD
Researcher in Structural Bioinformatics since the 20th Century
The Burnham Institute http://www.burnham.org
San Diego, California