olinq 0.1 · OCaml Package

type !'a sequence = ('a -> unit) -> unit

type !'a equal = 'a -> 'a -> bool

type !'a ord = 'a -> 'a -> int

type !'a hash = 'a -> int

type !'a or_error = [

| `Error of string
| `Ok of 'a

]

module Iterable : sig ... end

type (!'a, !'b) map = ('a, 'b) OLinq_map.t

type ('a, +'b) t constraint 'b = [< `Any | `AtMostOne | `One ]

type 'a t_any = ('a, [ `Any ]) t

type 'a t_one = ('a, [ `One ]) t

type 'a t_at_most_one = ('a, [ `AtMostOne ]) t

val empty : ('a, [< `Any | `AtMostOne | `One AtMostOne ]) t

val return : 'a -> ('a, [< `Any | `AtMostOne | `One One ]) t

val of_list : 'a list -> ('a, [ `Any ]) t

val of_array : 'a array -> ('a, [ `Any ]) t

val of_array_i : 'a array -> (int * 'a, [ `Any ]) t

val range : int -> int -> (int, [ `Any ]) t

val (--) : int -> int -> (int, [ `Any ]) t

val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b, [ `Any ]) t

val of_seq : 'a sequence -> ('a, [ `Any ]) t

val of_vec : 'a OLinq_vec.t -> ('a, [ `Any ]) t

val of_queue : 'a Queue.t -> ('a, [ `Any ]) t

val of_stack : 'a Stack.t -> ('a, [ `Any ]) t

val of_string : string -> (char, [ `Any ]) t

val of_map : ('a, 'b) map -> ('a * 'b, [ `Any ]) t

val of_multimap : ('a, 'b list) map -> ('a * 'b, [ `Any ]) t

val run : ?limit:int -> ('a, [< `Any | `AtMostOne | `One ]) t -> 'a Iterable.t

val run_list : ?limit:int -> ('a, [< `Any | `AtMostOne | `One ]) t -> 'a list

val run_array : ?limit:int -> ('a, [< `Any | `AtMostOne | `One ]) t -> 'a array

val run_vec : 
  ?limit:int ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  'a OLinq_vec.t

val run1 : ('a, [ `One ]) t -> 'a

val run_head : ('a, [< `Any | `AtMostOne | `One ]) t -> 'a option

val run1_exn : ('a, [< `Any | `AtMostOne | `One ]) t -> 'a

val map : 
  ('a -> 'b) ->
  ('a, [< `Any | `AtMostOne | `One ] as 'c) t ->
  ('b, 'c) t

val (>|=) : 
  ('a, [< `Any | `AtMostOne | `One ] as 'c) t ->
  ('a -> 'b) ->
  ('b, 'c) t

val filter : 
  ('a -> bool) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val size : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  (int, [< `Any | `AtMostOne | `One One ]) t

val choose : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One AtMostOne ]) t

val filter_map : 
  ('a -> 'b option) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [ `Any ]) t

val flat_map_seq : 
  ('a -> 'b sequence) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [ `Any ]) t

val flat_map_l : 
  ('a -> 'b list) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [ `Any ]) t

val flatten_list : 
  ('a list, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val flatten_seq : 
  ('a sequence, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val flatten_map : 
  (('a, 'b) map, [< `Any | `AtMostOne | `One ]) t ->
  ('a * 'b, [ `Any ]) t

val flatten_multimap : 
  (('a, 'b list) map, [< `Any | `AtMostOne | `One ]) t ->
  ('a * 'b, [ `Any ]) t

val take : int -> ('a, [< `Any | `AtMostOne | `One ]) t -> ('a, [ `Any ]) t

val take1 : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One AtMostOne ]) t

val take_while : 
  ('a -> bool) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val sort : ?cmp:'a ord -> unit -> ('a, [ `Any ]) t -> ('a, [ `Any ]) t

val sort_by : ?cmp:'b ord -> ('a -> 'b) -> ('a, [ `Any ]) t -> ('a, [ `Any ]) t

val distinct : ?cmp:'a ord -> unit -> ('a, [ `Any ]) t -> ('a, [ `Any ]) t

val group_by : 
  ?cmp:'b ord ->
  ?eq:'b equal ->
  ?hash:'b hash ->
  ('a -> 'b) ->
  ('a, [ `Any ]) t ->
  ('b * 'a list, [ `Any ]) t

val group_by_reflect : 
  ?cmp:'b ord ->
  ?eq:'b equal ->
  ?hash:'b hash ->
  ('a -> 'b) ->
  ('a, [ `Any ]) t ->
  (('b, 'a list) map, [< `Any | `AtMostOne | `One One ]) t

val count : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  unit ->
  ('a, [ `Any ]) t ->
  ('a * int, [ `Any ]) t

val count_reflect : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  unit ->
  ('a, [ `Any ]) t ->
  (('a, int) map, [< `Any | `AtMostOne | `One One ]) t

val fold : 
  ('b -> 'a -> 'b) ->
  'b ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [< `Any | `AtMostOne | `One One ]) t

val is_empty : 
  ('a, [< `Any | `AtMostOne ]) t ->
  (bool, [< `Any | `AtMostOne | `One One ]) t

val sum : 
  (int, [< `Any | `AtMostOne ]) t ->
  (int, [< `Any | `AtMostOne | `One One ]) t

val contains : 
  ?eq:'a equal ->
  'a ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  (bool, [< `Any | `AtMostOne | `One One ]) t

val average : 
  (int, [< `Any | `AtMostOne | `One ]) t ->
  (int, [< `Any | `AtMostOne | `One One ]) t

val max : 
  (int, [< `Any | `AtMostOne | `One ]) t ->
  (int, [< `Any | `AtMostOne | `One One ]) t

val min : 
  (int, [< `Any | `AtMostOne | `One ]) t ->
  (int, [< `Any | `AtMostOne | `One One ]) t

val for_all : 
  ('a -> bool) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  (bool, [< `Any | `AtMostOne | `One One ]) t

val exists : 
  ('a -> bool) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  (bool, [< `Any | `AtMostOne | `One One ]) t

val find : 
  ('a -> bool) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a option, [< `Any | `AtMostOne | `One One ]) t

val find_map : 
  ('a -> 'b option) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b option, [< `Any | `AtMostOne | `One One ]) t

val join : 
  ?cmp:'key ord ->
  ?eq:'key equal ->
  ?hash:'key hash ->
  ('a -> 'key) ->
  ('b -> 'key) ->
  merge:('key -> 'a -> 'b -> 'c option) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [< `Any | `AtMostOne | `One ]) t ->
  ('c, [ `Any ]) t

val group_join : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  ('b -> 'a) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [< `Any | `AtMostOne | `One ]) t ->
  ('a * 'b list, [ `Any ]) t

val group_join_reflect : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  ('b -> 'a) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [< `Any | `AtMostOne | `One ]) t ->
  (('a, 'b list) map, [< `Any | `AtMostOne | `One One ]) t

val product : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [< `Any | `AtMostOne | `One ]) t ->
  ('a * 'b, [ `Any ]) t

val append : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val inter : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val union : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val diff : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val subset : 
  ?cmp:'a ord ->
  ?eq:'a equal ->
  ?hash:'a hash ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  (bool, [ `One ]) t

val map_fst : 
  ('a -> 'b) ->
  ('a * 'c, [< `Any | `AtMostOne | `One ] as 'd) t ->
  ('b * 'c, 'd) t

val map_snd : 
  ('a -> 'b) ->
  ('c * 'a, [< `Any | `AtMostOne | `One ] as 'd) t ->
  ('c * 'b, 'd) t

val flatten_opt : 
  ('a option, [< `Any | `AtMostOne | `One ]) t ->
  ('a, [ `Any ]) t

val pure : 'a -> ('a, [< `Any | `AtMostOne | `One ]) t

val app : 
  ('a -> 'b, [< `Any | `AtMostOne | `One ] as 'c) t ->
  ('a, 'c) t ->
  ('b, 'c) t

val (<*>) : 
  ('a -> 'b, [< `Any | `AtMostOne | `One ] as 'c) t ->
  ('a, 'c) t ->
  ('b, 'c) t

val flat_map : 
  ('a -> ('b, [< `Any | `AtMostOne | `One ]) t) ->
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('b, [ `Any ]) t

val (>>=) : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a -> ('b, [< `Any | `AtMostOne | `One ]) t) ->
  ('b, [ `Any ]) t

val lazy_ : ('a lazy_t, [< `Any | `AtMostOne | `One ] as 'b) t -> ('a, 'b) t

exception UnwrapNone

val opt_unwrap_exn : 
  ('a option, [< `Any | `AtMostOne | `One ] as 'b) t ->
  ('a, 'b) t

module Infix : sig ... end

val reflect_vec : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a OLinq_vec.t, [< `Any | `AtMostOne | `One One ]) t

val reflect_list : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a list, [< `Any | `AtMostOne | `One One ]) t

val reflect_hashtbl : 
  ('a * 'b, [< `Any | `AtMostOne | `One ]) t ->
  (('a, 'b) Hashtbl.t, [< `Any | `AtMostOne | `One One ]) t

val reflect_queue : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a Queue.t, [< `Any | `AtMostOne | `One One ]) t

val reflect_stack : 
  ('a, [< `Any | `AtMostOne | `One ]) t ->
  ('a Stack.t, [< `Any | `AtMostOne | `One One ]) t

module AdaptSet (S : Set.S) : sig ... end

module AdaptMap (M : Map.S) : sig ... end

module IO : sig ... end

package olinq