Commits

james woodyatt committed 39b0375

Checkpoint. Exploring the possibility of refactoring some modules.

Comments (0)

Files changed (11)

         stdtime
         journal
         seq
+        dyn
         deque
         flow
+        llscan
+        xdfa
+        message
         heap
         pqueue
         map
         machine
         unicode
         parser
-        message
         dfa
         regex
         lex
+(*---------------------------------------------------------------------------*
+  $Change$
+  Copyright (C) 2011, james woodyatt
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *---------------------------------------------------------------------------*)
+
+type ('i, 'o) t = ('i, 'o) s Lazy.t and ('i, 'o) s =
+    | Z
+    | P of 'o * ('i, 'o) t
+    | Q of ('i -> ('i, 'o) s)
+
+let fin = lazy Z
+(* let nil = let rec put x = P (x, get) and get = lazy (Q put) in get *)
+
+let filter f =
+    let rec init = lazy (Q get)
+    and get i = if f i then P (i, init) else Z in
+    init
+
+let commute =
+    let rec start w s = lazy (loop w s)
+    and loop w s =
+        match Lazy.force w with
+        | Z -> Cf_seq.Z
+        | P (hd, tl) -> Cf_seq.P (hd, start tl s)
+        | Q f ->
+            match Lazy.force s with
+            | Cf_seq.P (hd, tl) -> loop (lazy (f hd)) tl
+            | Cf_seq.Z -> Cf_seq.Z
+    in
+    start
+
+let copy =
+    let rec start w = lazy (loop w)
+    and loop w =
+        match Lazy.force w with
+        | Z -> Z
+        | P (hd, tl) -> P ((hd, hd), start tl)
+        | Q f -> Q (fun i -> loop (lazy (f i)))
+    in
+    start
+
+let fuse =
+    let rec start a b = lazy (loop a b)
+    and loop a b =
+        match Lazy.force a, Lazy.force b with
+        | Z, _
+        | _, Z ->
+            Z
+        | P (hd1, tl1), P (hd2, tl2) ->
+            P ((hd1, hd2), start tl1 tl2)
+        | Q f1, Q f2 ->
+            Q (fun i -> loop (lazy (f1 i)) (lazy (f2 i)))
+        | Q f, P _ ->
+            Q (fun x -> loop (lazy (f x)) b)
+        | P _, Q f ->
+            Q (fun y -> loop a (lazy (f y)))
+    in
+    start
+
+(*--- $File$ ---*)
+(*---------------------------------------------------------------------------*
+  $Change$
+  Copyright (C) 2011, james woodyatt
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *---------------------------------------------------------------------------*)
+
+type ('i, 'o) t = ('i, 'o) s Lazy.t and ('i, 'o) s =
+    | Z
+    | P of 'o * ('i, 'o) t
+    | Q of ('i -> ('i, 'o) s)
+
+val commute: ('i, 'o) t -> 'i Cf_seq.t -> 'o Cf_seq.t
+
+val fin: ('i, 'o) t
+
+val filter: ('i -> bool) -> ('i, 'i) t
+
+val copy: ('i, 'o) t -> ('i, 'o * 'o) t
+val fuse: ('i, 'a) t -> ('i, 'b) t -> ('i, 'a * 'b) t
+
+(*--- $File$ ---*)
+(*---------------------------------------------------------------------------*
+  $Change$
+  Copyright (C) 2011, james woodyatt
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *---------------------------------------------------------------------------*)
+
+type ('s, 'r) t = 's Cf_seq.t -> ('r * 's Cf_seq.t) option
+
+let nil _ = None
+let ret a s = Some (a, s)
+
+let bind m f s =
+    match m s with
+    | None -> None
+    | Some (r, s) -> f r s
+
+let fin s =
+    match Lazy.force s with
+    | Cf_seq.Z -> Some ((), s)
+    | Cf_seq.P _ -> None
+
+let sat f s =
+    match Lazy.force s with
+    | Cf_seq.P (hd, tl) when f hd -> Some (hd, tl)
+    | (Cf_seq.P _ | Cf_seq.Z) -> None
+
+let tok f s =
+    match Lazy.force s with
+    | Cf_seq.Z -> None
+    | Cf_seq.P (hd, tl) ->
+        match f hd with
+        | Some r -> Some (r, tl)
+        | None -> None
+
+let opt p s =
+    Some begin
+        match p s with
+        | None -> None, s
+        | Some (r, s) -> Some r, s
+    end
+
+let seq =
+    let rec loop u p s =
+        match p s with
+        | None -> Some (List.rev u, s)
+        | Some (r, s) -> loop (r :: u) p s
+    in
+    let start p s = loop [] p s in
+    start
+
+let seq1 p =
+    bind p (fun hd -> bind (seq p) (fun tl -> ret (hd, tl)))
+
+let rec alt ps s =
+    match ps with
+    | [] -> None
+    | hd :: tl ->
+        match hd s with
+        | None -> alt tl s
+        | Some _ as r -> r
+
+let rec altz pz s =
+    match Lazy.force pz with
+    | Cf_seq.Z -> None
+    | Cf_seq.P (hd, tl) ->
+        match hd s with
+        | None -> altz tl s
+        | Some _ as r -> r
+
+let rec filter f p s =
+    match p s with
+    | None -> None
+    | Some (x, s) as v -> if f x then v else filter f p s
+
+let map f p s =
+    match p s with
+    | None -> None
+    | Some (r, s) -> Some (f r, s)
+
+let rec optmap f p s =
+    match p s with
+    | None -> None
+    | Some (x, s) ->
+        match f x with
+        | None -> optmap f p s
+        | Some y -> Some (y, s)
+
+let rec unfold =
+    let rec loop p s =
+        match p s with
+        | None -> Cf_seq.Z
+        | Some (r, s) -> Cf_seq.P (r, lazy (loop p s))
+    in
+    let start p s = lazy (loop p s) in
+    start
+
+exception Error
+
+let err =
+    let aux _ = Error in
+    fun ?(f = aux) () s -> raise (f s)
+
+let req ?f p s =
+    match p s with
+    | None -> err ?f () s
+    | Some _ as r -> r
+
+(*--- $File$ ---*)
+(*---------------------------------------------------------------------------*
+  $Change$
+  Copyright (C) 2011, james woodyatt
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *---------------------------------------------------------------------------*)
+
+type ('s, 'r) t = 's Cf_seq.t -> ('r * 's Cf_seq.t) option
+
+val nil: ('s, 'r) t
+val ret: 'r -> ('s, 'r) t
+val bind: ('s, 'a) t -> ('a -> ('s, 'b) t) -> ('s, 'b) t
+val fin: ('s, unit) t
+val sat: ('s -> bool) -> ('s, 's) t
+val tok: ('s -> 'r option) -> ('s, 'r) t
+val opt: ('s, 'r) t -> ('s, 'r option) t
+val seq: ('s, 'r) t -> ('s, 'r list) t
+val seq1: ('s, 'r) t -> ('s, 'r * 'r list) t
+val alt: ('s, 'r) t list -> ('s, 'r) t
+val altz: ('s, 'r) t Cf_seq.t -> ('s, 'r) t
+
+val filter: ('r -> bool) -> ('s, 'r) t -> ('s, 'r) t
+val map: ('x -> 'y) -> ('s, 'x) t -> ('s, 'y) t
+val optmap: ('x -> 'y option) -> ('s, 'x) t -> ('s, 'y) t
+
+val unfold: ('s, 'r) t -> 's Cf_seq.t -> 'r Cf_seq.t
+
+exception Error
+val err: ?f:('s Cf_seq.t -> exn) -> unit -> ('s, 'r) t
+val req: ?f:('s Cf_seq.t -> exn) -> ('s, 'r) t -> ('s, 'r) t
+
+(*--- $File$ ---*)
         | _, _ -> Z
     end
 
+let rec weave f c s =
+    lazy begin
+        match Lazy.force s with
+        | P (hd, tl) -> let c, hd = f c hd in P (hd, weave f c tl)
+        | Z -> Z
+    end
+
+let rec optweave =
+    let rec loop f c s =
+        match Lazy.force s with
+        | Z -> Z
+        | P (hd, tl) ->
+            let c, hd = f c hd in
+            match hd with
+            | Some hd -> P (hd, lazy (loop f c tl))
+            | None -> loop f c tl
+    in
+    let start f c s = lazy (loop f c s) in
+    start
+
 let rec iterate2 f s0 s1 =
     match Lazy.force s0, Lazy.force s1 with
     | P (hd1, tl1), P (hd2, tl2) -> f hd1 hd2; iterate2 f tl1 tl2
     fun f s1 s2 ->
         lazy (outer f s1 s2)
 
+let rec weave2 =
+    let rec loop f c s1 s2 =
+        match Lazy.force s1, Lazy.force s2 with
+        | P (hd1, tl1), P (hd2, tl2) ->
+            let c, hd3 = f c hd1 hd2 in P (hd3, lazy (loop f c tl1 tl2))
+        | _, _ ->
+            Z
+    in
+    let start f c sa sb = lazy (loop f c sa sb) in
+    start
+
+let rec optweave2 =
+    let rec loop f c s1 s2 =
+        match Lazy.force s1, Lazy.force s2 with
+        | P (hd1, tl1), P (hd2, tl2) ->
+            let c, v = f c hd1 hd2 in begin
+                match v with
+                | Some hd -> P (hd, lazy (loop f c tl1 tl2))
+                | None -> loop f c tl1 tl2
+            end
+        | _, _ ->
+            Z
+    in
+    let start f c s1 s2 = lazy (loop f c s1 s2) in
+    start
+
 let rec of_channel c =
     lazy (try P (input_char c, of_channel c) with End_of_file -> Z)
 
 *)
 val combine: 'a t -> 'b t -> ('a * 'b) t
 
+(** [weave f c s] returns the sequence composed by applying each element of [s]
+    to [f] along with the initial value [c] for the first element and the
+    first part of the result of the previous application for each succeeding
+    element in [s].  The second part of the result of applying [f] is produced
+    in the output sequence.
+*)
+val weave: ('c -> 'a -> 'c * 'b) -> 'c -> 'a t -> 'b t
+
+(** [optweave f c s] returns the sequence composed by applying each element of
+    [s] to [f] along with the initial value [c] for the first element and the
+    first part of the result of the previous application for each succeeding
+    element in [s].  The second part of the result of applying [f], when not
+    [None], is produced in the output sequence.
+*)
+val optweave: ('c -> 'a -> 'c * 'b option) -> 'c -> 'a t -> 'b t
+
 (** [iterate2 f a b] is like [iterate f s], except it operates on a pair of
     sequences simultaneously, until one or both sequences reaches its end.
 *)
 *)
 val seqmap2: ('a -> 'b -> 'c t) -> 'a t -> 'b t -> 'c t
 
+(** [weave2 f c a b] is like [weave f c s], except it operates on a pair of
+    sequences simulataneously, until one or both sequences reaches its end.
+*)
+val weave2: ('x -> 'a -> 'b -> 'x * 'c) -> 'x -> 'a t -> 'b t -> 'c t
+
+(** [optweave2 f c a b] is like [optweave f c s], except it operates on a pair
+    of sequences simulataneously, until one or both sequences reaches its end.
+*)
+val optweave2: ('x -> 'a -> 'b -> 'x * 'c option) -> 'x -> 'a t -> 'b t -> 'c t
+
 (** [of_channel c] returns the sequence of characters produced by reading them
     on demand from the channel [c].  (Note: this means that dueling [char t]
     sequences reading from the same [in_channel] object may interfere with one
+(*---------------------------------------------------------------------------*
+  $Change$
+  Copyright (C) 2011, james woodyatt
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *---------------------------------------------------------------------------*)
+
+module N_set = Cf_rbtree.Set(Cf_ordered.Int_order)
+module N_map = Cf_rbtree.Map(Cf_ordered.Int_order)
+
+let identity x = x
+
+module type Symbol = sig
+    type t and 'a map
+    val map: (t -> 'a) -> 'a map
+    val get: 'a map -> t -> 'a
+end
+
+module type T = sig
+    module S: Symbol
+    
+    type 'a x
+    
+    val nil: 'a x
+    
+    type 'a r
+end
+
+module Create(S: Symbol) : (T with module S = S) = struct
+    module S = S
+    
+    class virtual ['a] satisfier state =
+        object(_:'self)
+            constraint 'f = int -> (S.t, 'a) Cf_llscan.t
+            
+            val state_ = state
+            
+            method state = state_
+            method follow u = {< state_ = N_set.union state_ u >}
+            method virtual edge: S.t -> N_set.t -> N_set.t
+            method accept = (None : 'f option)
+        end
+    
+    let literal c =
+        object
+            inherit ['r] satisfier N_set.nil
+            method edge n u = if n = c then N_set.union state_ u else u
+        end
+        
+    let mapped f =
+        object
+            inherit ['r] satisfier N_set.nil
+            method edge n u = if f n then N_set.union state_ u else u
+        end
+    
+    type 's y = {
+        y_counter: int;
+        y_first: N_set.t;
+        y_last: N_set.t;
+        y_follow: 's N_map.t -> 's N_map.t;
+    } constraint 's = 'a #satisfier
+    
+    type 's w = {
+        w_null: bool;
+        w_cons: int -> 's y;
+    }
+    
+    type 'a x = 'a satisfier w
+    
+    let nil = {
+        w_null = true;
+        w_cons = fun i -> {
+            y_counter = i;
+            y_first = N_set.nil;
+            y_last = N_set.nil;
+            y_follow = identity;
+        }
+    }
+    
+    let expr n = {
+        w_null = false;
+        w_cons = fun i ->
+            let s = N_set.singleton i in {
+                y_counter = succ i;
+                y_first = s;
+                y_last = s;
+                y_follow = fun m -> N_map.replace (i, n) m;
+            }
+    }
+    
+    type 'a r = 'a satisfier w
+end
+
+(*--- $File$ ---*)
+(*---------------------------------------------------------------------------*
+  $Change$
+  Copyright (C) 2011, james woodyatt
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *---------------------------------------------------------------------------*)
+
+(*--- $File$ ---*)
 + Fixed an error in the Nx_socket module where the message flags on send and
   recv calls would be passed incorrectly, with MSG_DONTWAIT applied.
 
++ Added Cf_seq.weave, Cf_seq.optweave and their paired cognates.  See PROBLEMS
+  for related issues.
+
++ Refactored the functional parser modules.  The Cf_llscan module now has the
+  core LL(x) parsing monad.
 
 ==== Version 1.0 ===
 
 Open issues in development:
 
-+ (Cf_gadget): Write some documentation about polymorphic variants as channel
-    type parameters.
++ (Cf_dyn): Exploring this as a refactoring of the Cf_flow module, with all new
+    functions and maybe some different operators.
+
++ (Cf_llscan): Exploring this as a refactoring of the Cf_parser module and its
+    cognates.  Needs documentation.  Also need new modules for lexing, parsing
+    and regular grammars.
+
++ (Cf_seq): The tentative weave functions are probably a bad idea.  It probably
+    makes more sense to unfold/weave the new Cf_llscan.t instead.
 
 + (Cf_rbtree): Document the complexity of the [incr_next] and [decr_next]
     functions.  The binary set functions could be improved for performance by
     using recursive [join] and [split] functions.  Need set disjoint.
 
++ (Cf_gadget): Write some documentation about polymorphic variants as channel
+    type parameters.
+
 + (Cf_tai64_p, Cf_tai64n_p): No support for 32-bit environments where the C
     compiler does not offer support for 64-bit integers with
     'unsigned long long'.  Do such environments exist anymore?