package seqes

  1. Overview
  2. Docs

Module Monadic.Make1Source

Make a specialised Seq-like module based on a given Monad.

Parameters

module Mon : sig ... end

Signature

Sourcetype 'a t = unit -> 'a node Mon.t

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

Sourceand 'a node =
  1. | Nil
  2. | Cons of 'a * 'a t

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

See the documentation of Sigs1.SEQMON1ALL for more details.

Any monad that we can use to produce transformers, we can also use to produce traversors. Thus, SEQMON1TRANSFORMERS includes SEQMON1TRAVERSORS and all the functors producing transformer also produce traversors.

Sourceval iter : ('a -> unit) -> 'a t -> unit Mon.t

See Stdlib.Seq.iter

Sourceval fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a Mon.t

See Stdlib.Seq.fold_left

Sourceval iteri : (int -> 'a -> unit) -> 'a t -> unit Mon.t

See Stdlib.Seq.iteri

Sourceval fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b Mon.t

See Stdlib.Seq.fold_lefti

Sourceval for_all : ('a -> bool) -> 'a t -> bool Mon.t

See Stdlib.Seq.for_all

Sourceval exists : ('a -> bool) -> 'a t -> bool Mon.t

See Stdlib.Seq.exists

Sourceval find : ('a -> bool) -> 'a t -> 'a option Mon.t

See Stdlib.Seq.find

Sourceval find_map : ('a -> 'b option) -> 'a t -> 'b option Mon.t

See Stdlib.Seq.find_map

Sourceval iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit Mon.t

See Stdlib.Seq.iter2

Sourceval fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a Mon.t

See Stdlib.Seq.fold_left2

Sourceval for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool Mon.t

See Stdlib.Seq.for_all2

Sourceval exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool Mon.t

See Stdlib.Seq.exists2

Sourceval init : int -> (int -> 'a) -> 'a t

See Stdlib.Seq.init

Sourceval unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t

See Stdlib.Seq.unfold

Sourceval forever : (unit -> 'a) -> 'a t

See Stdlib.Seq.forever

Sourceval iterate : ('a -> 'a) -> 'a -> 'a t

See Stdlib.Seq.iterate

Sourceval map : ('a -> 'b) -> 'a t -> 'b t

See Stdlib.Seq.map

Sourceval mapi : (int -> 'a -> 'b) -> 'a t -> 'b t

See Stdlib.Seq.mapi

Sourceval filter : ('a -> bool) -> 'a t -> 'a t

See Stdlib.Seq.filter

Sourceval filter_map : ('a -> 'b option) -> 'a t -> 'b t

See Stdlib.Seq.filter_map

Sourceval scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t

See Stdlib.Seq.scan

Sourceval take_while : ('a -> bool) -> 'a t -> 'a t

See Stdlib.Seq.take_while

Sourceval drop_while : ('a -> bool) -> 'a t -> 'a t

See Stdlib.Seq.drop_while

Sourceval group : ('a -> 'a -> bool) -> 'a t -> 'a t t

See Stdlib.Seq.group

Sourceval map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

See Stdlib.Seq.map2

Sourceval map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

See Stdlib.Seq.map_product

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

See Stdlib.Seq.partition_map

Sourceval partition : ('a -> bool) -> 'a t -> 'a t * 'a t

See Stdlib.Seq.partition

Sourceval is_empty : 'a t -> bool Mon.t

See Stdlib.Seq.is_empty

Sourceval uncons : 'a t -> ('a * 'a t) option Mon.t

See Stdlib.Seq.uncons

Sourceval length : 'a t -> int Mon.t

See Stdlib.Seq.length

Sourceval equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool Mon.t

See Stdlib.Seq.equal

Sourceval compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int Mon.t

See Stdlib.Seq.compare

Sourceval empty : 'a t

See Stdlib.Seq.empty

Sourceval return : 'a -> 'a t

See Stdlib.Seq.return

Sourceval cons : 'a -> 'a t -> 'a t

See Stdlib.Seq.cons

Sourceval repeat : 'a -> 'a t

See Stdlib.Seq.repeat

Sourceval cycle : 'a t -> 'a t

See Stdlib.Seq.cycle

Sourceval take : int -> 'a t -> 'a t

See Stdlib.Seq.take

Sourceval drop : int -> 'a t -> 'a t

See Stdlib.Seq.drop

Sourceval memoize : 'a t -> 'a t

See Stdlib.Seq.memoize

Sourceval once : 'a t -> 'a t

See Stdlib.Seq.once

Sourceval transpose : 'a t t -> 'a t t

See Stdlib.Seq.transpose

Sourceval append : 'a t -> 'a t -> 'a t

See Stdlib.Seq.append

Sourceval concat : 'a t t -> 'a t

See Stdlib.Seq.concat

Sourceval flat_map : ('a -> 'b t) -> 'a t -> 'b t

See Stdlib.Seq.flat_map

Sourceval concat_map : ('a -> 'b t) -> 'a t -> 'b t

See Stdlib.Seq.concat_map

Sourceval zip : 'a t -> 'b t -> ('a * 'b) t

See Stdlib.Seq.zip

Sourceval interleave : 'a t -> 'a t -> 'a t

See Stdlib.Seq.interleave

Sourceval sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t

See Stdlib.Seq.sorted_merge

Sourceval product : 'a t -> 'b t -> ('a * 'b) t

See Stdlib.Seq.product

Sourceval unzip : ('a * 'b) t -> 'a t * 'b t

See Stdlib.Seq.unzip

Sourceval split : ('a * 'b) t -> 'a t * 'b t

See Stdlib.Seq.split

Sourceval of_dispenser : (unit -> 'a option Mon.t) -> 'a t

See Stdlib.Seq.of_dispenser

Sourceval to_dispenser : 'a t -> unit -> 'a option Mon.t

See Stdlib.Seq.to_dispenser

Sourceval ints : int -> int t

See Stdlib.Seq.ints

Sourceval of_seq : 'a Seq.t -> 'a t

See Stdlib.Seq.of_seq

Sourcemodule 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 = Make(Mon) then SeqMon.M.map has type ('a -> 'b Mon.t) -> 'a t -> 'b t and SeqMon.M.iter has type ('a -> unit mon) -> 'a t -> unit mon.

Sourcemodule 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 Mun.t) -> 'a t -> 'b t.

Sourcemodule 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).