package gen

You can search for identifiers within the package.

in-package search v0.2.0

package gen

gen
- Library gen
  - Gen
    
    S
    
    Infix
    
    Restart
    
    Infix
    
    IO
  - GenClone
    
    IO
  - GenLabels
    
    S
    
    Infix
    
    Restart
    
    Infix
    
    IO
  - GenLabels_intf
    
    S
    
    Infix
  - GenM
    
    MONAD
    
    Make
    
    M
    
    Infix
  - GenMList
  - GenM_intf
    
    MONAD
    
    S
    
    M
    
    Infix
  - GenShims_
    
    Stdlib
  - Gen_intf
    
    S
    
    Infix
- Sources
  - gen
    
    GenShims_.ml
    
    gen.ml
    
    genClone.ml
    
    genLabels.ml
    
    genLabels_intf.ml
    
    genM.ml
    
    genMList.ml
    
    genM_intf.ml
    
    gen_intf.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `GenLabels.Restart`Source

Sourcetype 'a t = unit -> 'a gen

Sourcetype 'a restartable = 'a t

include S with type 'a t := 'a restartable

Sourceval empty : 'a restartable

Empty generator, with no elements

Sourceval singleton : 'a -> 'a restartable

One-element generator

Sourceval return : 'a -> 'a restartable

Alias to singleton

since 0.3

Sourceval repeat : 'a -> 'a restartable

Repeat same element endlessly

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

iterate x f is [x; f x; f (f x); f (f (f x)); ...]

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

Dual of fold, with a deconstructing operation. It keeps on unfolding the 'b value into a new 'b, and a 'a which is yielded, until None is returned.

Sourceval init : ?limit:int -> (int -> 'a) -> 'a restartable

Calls the function, starting from 0, on increasing indices. If limit is provided and is a positive int, iteration will stop at the limit (excluded). For instance init ~limit:4 id will yield 0, 1, 2, and 3.

Basic combinators

Note: those combinators, applied to generators (not restartable generators) consume their argument. Sometimes they consume it lazily, sometimes eagerly, but in any case once f gen has been called (with f a combinator), gen shouldn't be used anymore.

Sourceval is_empty : _ restartable -> bool

Check whether the gen is empty. Pops an element, if any

Sourceval fold : f:('b -> 'a -> 'b) -> init:'b -> 'a restartable -> 'b

Fold on the generator, tail-recursively. Consumes the generator.

Sourceval reduce : f:('a -> 'a -> 'a) -> 'a restartable -> 'a

Fold on non-empty sequences. Consumes the generator.

raises Invalid_argument
on an empty gen

Sourceval scan : f:('b -> 'a -> 'b) -> init:'b -> 'a restartable -> 'b restartable

Like fold, but keeping successive values of the accumulator. Consumes the generator.

Source

val unfold_scan : 
  ('b -> 'a -> 'b * 'c) ->
  'b ->
  'a restartable ->
  'c restartable

A mix of unfold and scan. The current state is combined with the current element to produce a new state, and an output value of type 'c.

since 0.2.2

Sourceval iter : f:('a -> unit) -> 'a restartable -> unit

Iterate on the gen, consumes it.

Sourceval iteri : f:(int -> 'a -> unit) -> 'a restartable -> unit

Iterate on elements with their index in the gen, from 0, consuming it.

Sourceval length : _ restartable -> int

Length of an gen (linear time), consuming it

Sourceval map : f:('a -> 'b) -> 'a restartable -> 'b restartable

Lazy map. No iteration is performed now, the function will be called when the result is traversed.

Sourceval mapi : f:(int -> 'a -> 'b) -> 'a restartable -> 'b restartable

Lazy map with indexing starting from 0. No iteration is performed now, the function will be called when the result is traversed.

since 0.5

Source

val fold_map : 
  f:('b -> 'a -> 'b) ->
  init:'b ->
  'a restartable ->
  'b restartable

Lazy fold and map. No iteration is performed now, the function will be called when the result is traversed. The result is an iterator over the successive states of the fold.

since 0.2.4

Sourceval append : 'a restartable -> 'a restartable -> 'a restartable

Append the two gens; the result contains the elements of the first, then the elements of the second gen.

Sourceval flatten : 'a GenLabels_intf.gen restartable -> 'a restartable

Flatten the generator of generators

Source

val flat_map : 
  f:('a -> 'b GenLabels_intf.gen) ->
  'a restartable ->
  'b restartable

Monadic bind; each element is transformed to a sub-gen which is then iterated on, before the next element is processed, and so on.

Sourceval mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a restartable -> bool

Is the given element, member of the gen?

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

Take at most n elements

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

Drop n elements

Sourceval nth : int -> 'a restartable -> 'a

n-th element, or Not_found

raises Not_found
if the generator contains less than n arguments

Sourceval take_nth : int -> 'a restartable -> 'a restartable

take_nth n g returns every element of g whose index is a multiple of n. For instance take_nth 2 (1--10) |> to_list will return 1;3;5;7;9

Sourceval filter : f:('a -> bool) -> 'a restartable -> 'a restartable

Filter out elements that do not satisfy the predicate.

Sourceval take_while : f:('a -> bool) -> 'a restartable -> 'a restartable

Take elements while they satisfy the predicate. The initial generator itself is not to be used anymore after this.

Source

val fold_while : 
  f:('a -> 'b -> 'a * [ `Stop | `Continue ]) ->
  init:'a ->
  'b restartable ->
  'a

Fold elements until ('a, `Stop) is indicated by the accumulator.

since 0.2.4

Sourceval drop_while : f:('a -> bool) -> 'a restartable -> 'a restartable

Drop elements while they satisfy the predicate. The initial generator itself should not be used anymore, only the result of drop_while.

Sourceval filter_map : f:('a -> 'b option) -> 'a restartable -> 'b restartable

Maps some elements to 'b, drop the other ones

Sourceval zip_index : 'a restartable -> (int * 'a) restartable

Zip elements with their index in the gen

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

Unzip into two sequences, splitting each pair

Source

val partition : 
  f:('a -> bool) ->
  'a restartable ->
  'a restartable * 'a restartable

partition p l returns the elements that satisfy p, and the elements that do not satisfy p

Sourceval for_all : f:('a -> bool) -> 'a restartable -> bool

Is the predicate true for all elements?

Sourceval exists : f:('a -> bool) -> 'a restartable -> bool

Is the predicate true for at least one element?

Sourceval min : ?lt:('a -> 'a -> bool) -> 'a restartable -> 'a

Minimum element, according to the given comparison function.

raises Invalid_argument
if the generator is empty

Sourceval max : ?lt:('a -> 'a -> bool) -> 'a restartable -> 'a

Maximum element, see min

raises Invalid_argument
if the generator is empty

Sourceval eq : ?eq:('a -> 'a -> bool) -> 'a restartable -> 'a restartable -> bool

Equality of generators.

Sourceval lexico : ?cmp:('a -> 'a -> int) -> 'a restartable -> 'a restartable -> int

Lexicographic comparison of generators. If a generator is a prefix of the other one, it is considered smaller.

Sourceval compare : ?cmp:('a -> 'a -> int) -> 'a restartable -> 'a restartable -> int

Synonym for lexico

Sourceval find : f:('a -> bool) -> 'a restartable -> 'a option

find p e returns the first element of e to satisfy p, or None.

Sourceval sum : int restartable -> int

Sum of all elements

Multiple iterators

Source

val map2 : 
  f:('a -> 'b -> 'c) ->
  'a restartable ->
  'b restartable ->
  'c restartable

Map on the two sequences. Stops once one of them is exhausted.

Sourceval iter2 : f:('a -> 'b -> unit) -> 'a restartable -> 'b restartable -> unit

Iterate on the two sequences. Stops once one of them is exhausted.

Source

val fold2 : 
  f:('acc -> 'a -> 'b -> 'acc) ->
  init:'acc ->
  'a restartable ->
  'b restartable ->
  'acc

Fold the common prefix of the two iterators

Sourceval for_all2 : f:('a -> 'b -> bool) -> 'a restartable -> 'b restartable -> bool

Succeeds if all pairs of elements satisfy the predicate. Ignores elements of an iterator if the other runs dry.

Sourceval exists2 : f:('a -> 'b -> bool) -> 'a restartable -> 'b restartable -> bool

Succeeds if some pair of elements satisfy the predicate. Ignores elements of an iterator if the other runs dry.

Source

val zip_with : 
  f:('a -> 'b -> 'c) ->
  'a restartable ->
  'b restartable ->
  'c restartable

Combine common part of the gens (stops when one is exhausted)

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

Zip together the common part of the gens

Complex combinators

Sourceval merge : 'a GenLabels_intf.gen restartable -> 'a restartable

Pick elements fairly in each sub-generator. The merge of gens e1, e2, ... picks elements in e1, e2, in e3, e1, e2 .... Once a generator is empty, it is skipped; when they are all empty, and none remains in the input, their merge is also empty. For instance, merge [1;3;5] [2;4;6] will be, in disorder, 1;2;3;4;5;6.

Source

val intersection : 
  ?cmp:('a -> 'a -> int) ->
  'a restartable ->
  'a restartable ->
  'a restartable

Intersection of two sorted sequences. Only elements that occur in both inputs appear in the output

Source

val sorted_merge : 
  ?cmp:('a -> 'a -> int) ->
  'a restartable ->
  'a restartable ->
  'a restartable

Merge two sorted sequences into a sorted sequence

Source

val sorted_merge_n : 
  ?cmp:('a -> 'a -> int) ->
  'a restartable list ->
  'a restartable

Sorted merge of multiple sorted sequences

Sourceval tee : ?n:int -> 'a restartable -> 'a GenLabels_intf.gen list

Duplicate the gen into n generators (default 2). The generators share the same underlying instance of the gen, so the optimal case is when they are consumed evenly

Sourceval round_robin : ?n:int -> 'a restartable -> 'a GenLabels_intf.gen list

Split the gen into n generators in a fair way. Elements with index = k mod n with go to the k-th gen. n default value is 2.

Sourceval interleave : 'a restartable -> 'a restartable -> 'a restartable

interleave a b yields an element of a, then an element of b, and so on. When a generator is exhausted, this behaves like the other generator.

Sourceval intersperse : 'a -> 'a restartable -> 'a restartable

Put the separator element between all elements of the given gen

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

Cartesian product, in no predictable order. Works even if some of the arguments are infinite.

Sourceval group : ?eq:('a -> 'a -> bool) -> 'a restartable -> 'a list restartable

Group equal consecutive elements together.

Sourceval uniq : ?eq:('a -> 'a -> bool) -> 'a restartable -> 'a restartable

Remove consecutive duplicate elements. Basically this is like fun e -> map List.hd (group e).

Sourceval sort : ?cmp:('a -> 'a -> int) -> 'a restartable -> 'a restartable

Sort according to the given comparison function. The gen must be finite.

Sourceval sort_uniq : ?cmp:('a -> 'a -> int) -> 'a restartable -> 'a restartable

Sort and remove duplicates. The gen must be finite.

Sourceval chunks : int -> 'a restartable -> 'a array restartable

chunks n e returns a generator of arrays of length n, composed of successive elements of e. The last array may be smaller than n

Sourceval permutations : 'a restartable -> 'a list restartable

Permutations of the gen.

since 0.2.2

Sourceval permutations_heap : 'a restartable -> 'a array restartable

Permutations of the gen, using Heap's algorithm.

since 0.2.3

Sourceval combinations : int -> 'a restartable -> 'a list restartable

Combinations of given length. The ordering of the elements within each combination is unspecified. Example (ignoring ordering): combinations 2 (1--3) |> to_list = [[1;2]; [1;3]; [2;3]]

since 0.2.2

Sourceval power_set : 'a restartable -> 'a list restartable

All subsets of the gen (in no particular order). The ordering of the elements within each subset is unspecified.

since 0.2.2

Basic conversion functions

Sourceval of_list : 'a list -> 'a restartable

Enumerate elements of the list

Sourceval to_list : 'a restartable -> 'a list

non tail-call trasnformation to list, in the same order

Sourceval to_rev_list : 'a restartable -> 'a list

Tail call conversion to list, in reverse order (more efficient)

Sourceval to_array : 'a restartable -> 'a array

Convert the gen to an array (not very efficient)

Sourceval of_array : ?start:int -> ?len:int -> 'a array -> 'a restartable

Iterate on (a slice of) the given array

Sourceval of_string : ?start:int -> ?len:int -> string -> char restartable

Iterate on bytes of the string

Sourceval to_string : char restartable -> string

Convert into a string

Sourceval to_buffer : Buffer.t -> char restartable -> unit

Consumes the iterator and writes to the buffer

Sourceval rand_int : int -> int restartable

Random ints in the given range.

Sourceval int_range : ?step:int -> int -> int -> int restartable

int_range ~step a b generates integers between a and b, included, with steps of length step (1 if omitted). a is assumed to be smaller than b. step must not be null, but it can be negative for decreasing integers.

Sourceval lines : char restartable -> string restartable

Group together chars belonging to the same line

since 0.3

Sourceval unlines : string restartable -> char restartable

Explode lines into their chars, adding a '\n' after each one

since 0.3

Sourcemodule Infix : sig ... end

Sourceval (--) : int -> int -> int restartable

Synonym for int_range ~by:1

Sourceval (>>=) : 'a restartable -> ('a -> 'b GenLabels_intf.gen) -> 'b restartable

Monadic bind operator

Sourceval (>>|) : 'a restartable -> ('a -> 'b) -> 'b restartable

Infix map operator

since 0.2.3

Sourceval (>|=) : 'a restartable -> ('a -> 'b) -> 'b restartable

Infix map operator

since 0.2.3

Source

val pp : 
  ?start:string ->
  ?stop:string ->
  ?sep:string ->
  ?horizontal:bool ->
  (Format.formatter -> 'a -> unit) ->
  Format.formatter ->
  'a restartable ->
  unit

Pretty print the content of the generator on a formatter.

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

since 1.0

Sourceval to_iter : 'a restartable -> 'a GenLabels_intf.iter

since 1.0

Sourceval cycle : 'a t -> 'a t

Cycle through the enum, endlessly. The enum must not be empty.

Sourceval lift : ('a gen -> 'b) -> 'a t -> 'b

Sourceval lift2 : ('a gen -> 'b gen -> 'c) -> 'a t -> 'b t -> 'c

package gen

Module GenLabels.RestartSource

Basic combinators

Multiple iterators

Complex combinators

Basic conversion functions

Module `GenLabels.Restart`Source