seqes 0.2 · OCaml Package

The module type for the output of the Make2 module (below).

type ('a, 'e) mon

The type of the monad that the specialised Seq variation is built upon. This type is destructively substituted by the application of the functor; it is replaced by the actual monad type passed as parameter.

type ('a, 'e) t = unit -> (('a, 'e) node, 'e) mon

The Seq-like type: identical to Stdlib.Seq.t except for mon.

and ('a, 'e) node =

| Nil
| Cons of 'a * ('a, 'e) t

This include brings all the functions from the Stdlib.Seq module but specialised to the specialised Seq variation. E.g., given module SeqMon = Make2(Mon) then the function SeqMon.map has type ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t and SeqMon.iter has type ('a -> unit) -> ('a, 'e) t -> (unit, 'e) mon.

See the documentation of Sigs2.SEQMON2ALL for more details.

val iter : ('a -> unit) -> ('a, 'e) t -> (unit, 'e) mon

val fold_left : ('a -> 'b -> 'a) -> 'a -> ('b, 'e) t -> ('a, 'e) mon

val iteri : (int -> 'a -> unit) -> ('a, 'e) t -> (unit, 'e) mon

val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> ('a, 'e) t -> ('b, 'e) mon

val for_all : ('a -> bool) -> ('a, 'e) t -> (bool, 'e) mon

val exists : ('a -> bool) -> ('a, 'e) t -> (bool, 'e) mon

val find : ('a -> bool) -> ('a, 'e) t -> ('a option, 'e) mon

val find_map : ('a -> 'b option) -> ('a, 'e) t -> ('b option, 'e) mon

val iter2 : ('a -> 'b -> unit) -> ('a, 'e) t -> ('b, 'e) t -> (unit, 'e) mon

val fold_left2 : 
  ('a -> 'b -> 'c -> 'a) ->
  'a ->
  ('b, 'e) t ->
  ('c, 'e) t ->
  ('a, 'e) mon

val for_all2 : ('a -> 'b -> bool) -> ('a, 'e) t -> ('b, 'e) t -> (bool, 'e) mon

val exists2 : ('a -> 'b -> bool) -> ('a, 'e) t -> ('b, 'e) t -> (bool, 'e) mon

val init : int -> (int -> 'a) -> ('a, 'e) t

val unfold : ('b -> ('a * 'b) option) -> 'b -> ('a, 'e) t

val forever : (unit -> 'a) -> ('a, 'e) t

val iterate : ('a -> 'a) -> 'a -> ('a, 'e) t

val map : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t

val mapi : (int -> 'a -> 'b) -> ('a, 'e) t -> ('b, 'e) t

val filter : ('a -> bool) -> ('a, 'e) t -> ('a, 'e) t

val filter_map : ('a -> 'b option) -> ('a, 'e) t -> ('b, 'e) t

val scan : ('b -> 'a -> 'b) -> 'b -> ('a, 'e) t -> ('b, 'e) t

val take_while : ('a -> bool) -> ('a, 'e) t -> ('a, 'e) t

val drop_while : ('a -> bool) -> ('a, 'e) t -> ('a, 'e) t

val group : ('a -> 'a -> bool) -> ('a, 'e) t -> (('a, 'e) t, 'e) t

val map2 : ('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t

val map_product : ('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t

val partition_map : 
  ('a -> ('b, 'c) Either.t) ->
  ('a, 'e) t ->
  ('b, 'e) t * ('c, 'e) t

val partition : ('a -> bool) -> ('a, 'e) t -> ('a, 'e) t * ('a, 'e) t

val is_empty : ('a, 'e) t -> (bool, 'e) mon

val uncons : ('a, 'e) t -> (('a * ('a, 'e) t) option, 'e) mon

val length : ('a, 'e) t -> (int, 'e) mon

val equal : ('a -> 'b -> bool) -> ('a, 'e) t -> ('b, 'e) t -> (bool, 'e) mon

val compare : ('a -> 'b -> int) -> ('a, 'e) t -> ('b, 'e) t -> (int, 'e) mon

val empty : ('a, 'e) t

val return : 'a -> ('a, 'e) t

val cons : 'a -> ('a, 'e) t -> ('a, 'e) t

val repeat : 'a -> ('a, 'e) t

val cycle : ('a, 'e) t -> ('a, 'e) t

val take : int -> ('a, 'e) t -> ('a, 'e) t

val drop : int -> ('a, 'e) t -> ('a, 'e) t

val memoize : ('a, 'e) t -> ('a, 'e) t

val once : ('a, 'e) t -> ('a, 'e) t

val transpose : (('a, 'e) t, 'e) t -> (('a, 'e) t, 'e) t

val append : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t

val concat : (('a, 'e) t, 'e) t -> ('a, 'e) t

val flat_map : ('a -> ('b, 'e) t) -> ('a, 'e) t -> ('b, 'e) t

val concat_map : ('a -> ('b, 'e) t) -> ('a, 'e) t -> ('b, 'e) t

val zip : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t

val interleave : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t

val sorted_merge : ('a -> 'a -> int) -> ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t

val product : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t

val unzip : ('a * 'b, 'e) t -> ('a, 'e) t * ('b, 'e) t

val split : ('a * 'b, 'e) t -> ('a, 'e) t * ('b, 'e) t

val of_dispenser : (unit -> ('a option, 'e) mon) -> ('a, 'e) t

val to_dispenser : ('a, 'e) t -> unit -> ('a option, 'e) mon

val ints : int -> (int, 'e) t

val of_seq : 'a Seq.t -> ('a, 'e) t

module M : sig ... end

M is a module which contains a specialised subset of the functions from the Stdlib.Seq module. Specifically, it contains those functions which take a function as parameter (e.g., map but not length). Moreover, those parameter functions' return type is specialised to be within the mon monad. E.g., given module SeqMon = Make2(Mon) then SeqMon.M.map has type ('a -> ('b, 'e) Mon.t) -> ('a, 'e) t -> ('b, 'e) t and SeqMon.M.iter has type ('a -> (unit, 'e) mon) -> ('a, 'e) t -> (unit, 'e) mon.

module Make (Alt : sig ... end) (Glue : sig ... end) : sig ... end

Make is a functor to produce further M-like modules, but with parameter functions returning into a different monad. E.g., given module SeqMon = Make(Mon) and module SeqMonMun = SeqMon.Make(Mun) then SeqMonMun.map has type ('a -> ('b, 'e) Mun.t) -> ('a, 'e) t -> ('b, 'e) t.

module MakeTraversors
  (Alt : sig ... end)
  (Ret : sig ... end)
  (GlueAlt : sig ... end)
  (GlueMon : sig ... end) : 
  sig ... end

MakeTraversors is a functor similar to Make. It produces only a subset of the functions that Make does. Specifically, it produces the subset of functions that traverse a sequence (or part thereof) and return a value which is not a sequence (e.g., iter returning unit but not map returning a new sequence).

package seqes