The purpose it to provide powerful combinators to express iteration, transformation and combination of collections of items. This module depends on several other modules, including CCList and CCSequence.
Functions and operations are assumed to be referentially transparent, i.e. they should not rely on external side effects, they should not rely on the order of execution.
CCLinq.(
of_list [1;2;3]
|> flat_map_l (fun x -> CCList.(x -- (x+10)))
|> sort ()
|> count ()
|> M.to_list
|> run_exn
);;
- : (int * int) list = [(13, 1); (12, 2); (11, 3); (10, 3); (9, 3);
(8, 3); (7, 3); (6, 3); (5, 3); (4, 3); (3, 3); (2, 2); (1, 1)]
CCLinq.(
IO.slurp_file "/tmp/foo"
|> IO.lines
|> sort ()
|> IO.to_file_lines "/tmp/bar"
);;
- : `Ok ()Abstract type of collections of objects of type 'a. Those cannot be used directly, they are to be processed using a query (type 'at) and converted to some list/sequence/array
module PMap : sig ... endval start : 'a -> 'a tStart with a single value
val of_list : 'a list -> 'a collection tQuery that just returns the elements of the list
val of_array : 'a array -> 'a collection tval of_array_i : 'a array -> (int * 'a) collection tval of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) collection tval of_seq : 'a sequence -> 'a collection tQuery that returns the elements of the given sequence.
val of_queue : 'a Queue.t -> 'a collection tval of_stack : 'a Stack.t -> 'a collection tval of_string : string -> char collection tTraverse the characters of the string
val run_exn : 'a t -> 'aExecute the query, ignoring errors. Can raise an exception if some execution step does.
val map : ('a -> 'b) -> 'a collection t -> 'b collection tval filter : ('a -> bool) -> 'a collection t -> 'a collection tval choose : 'a collection t -> 'a tChoose one element (if any) in the collection. Fails if the collections is empty
val choose_err : 'a collection t -> 'a with_err tChoose one element or fail explicitely
val filter_map : ('a -> 'b option) -> 'a collection t -> 'b collection tFilter and map elements at once
val flat_map : ('a -> 'b collection) -> 'a collection t -> 'b collection tMonadic "bind", maps each element to a collection and flatten the result
val flat_map_seq : ('a -> 'b sequence) -> 'a collection t -> 'b collection tSame as flat_map but using sequences
val flat_map_l : ('a -> 'b list) -> 'a collection t -> 'b collection tval flatten : 'a collection collection t -> 'a collection tval flatten_l : 'a list collection t -> 'a collection tval take : int -> 'a collection t -> 'a collection ttake at most n elements
val take_while : ('a -> bool) -> 'a collection t -> 'a collection ttake elements while they satisfy a predicate
val sort : ?cmp:'a ord -> unit -> 'a collection t -> 'a collection tSort items by the given comparison function
val distinct : ?cmp:'a ord -> unit -> 'a collection t -> 'a collection tRemove duplicate elements from the input collection. All elements in the result are distinct.
module M : sig ... endval group_by :
?cmp:'b ord ->
?eq:'b equal ->
?hash:'b hash ->
('a -> 'b) ->
'a collection t ->
('b, 'a list) PMap.t tgroup_by f takes a collection c as input, and returns a multimap m such that for each x in c, x occurs in m under the key f x. In other words, f is used to obtain a key from x, and x is added to the multimap using this key.
val group_by' :
?cmp:'b ord ->
?eq:'b equal ->
?hash:'b hash ->
('a -> 'b) ->
'a collection t ->
('b * 'a list) collection tval count :
?cmp:'a ord ->
?eq:'a equal ->
?hash:'a hash ->
unit ->
'a collection t ->
('a, int) PMap.t tcount c returns a map from elements of c to the number of time those elements occur.
val count' : ?cmp:'a ord -> unit -> 'a collection t -> ('a * int) collection tval fold : ('b -> 'a -> 'b) -> 'b -> 'a collection t -> 'b tFold over the collection
val size : _ collection t -> int tCount how many elements the collection contains
val reduce :
('a -> 'b) ->
('a -> 'b -> 'b) ->
('b -> 'c) ->
'a collection t ->
'c treduce start mix stop q uses start on the first element of q, and combine the result with following elements using mix. The final value is transformed using stop.
val reduce_err :
('a -> 'b) ->
('a -> 'b -> 'b) ->
('b -> 'c) ->
'a collection t ->
'c with_err tSame as reduce but fails explicitely on empty collections.
val is_empty : 'a collection t -> bool tval sum : int collection t -> int tval contains : ?eq:'a equal -> 'a -> 'a collection t -> bool tval average : int collection t -> int tval max : int collection t -> int tval min : int collection t -> int tval average_err : int collection t -> int with_err tval max_err : int collection t -> int with_err tval min_err : int collection t -> int with_err tval for_all : ('a -> bool) -> 'a collection t -> bool tval exists : ('a -> bool) -> 'a collection t -> bool tval find : ('a -> bool) -> 'a collection t -> 'a option tval find_map : ('a -> 'b option) -> 'a collection t -> 'b option tval join :
?cmp:'key ord ->
?eq:'key equal ->
?hash:'key hash ->
('a -> 'key) ->
('b -> 'key) ->
merge:('key -> 'a -> 'b -> 'c option) ->
'a collection t ->
'b collection t ->
'c collection tjoin key1 key2 ~merge is a binary operation that takes two collections a and b, projects their elements resp. with key1 and key2, and combine values (x,y) from (a,b) with the same key using merge. If merge returns None, the combination of values is discarded.
val group_join :
?cmp:'a ord ->
?eq:'a equal ->
?hash:'a hash ->
('b -> 'a) ->
'a collection t ->
'b collection t ->
('a, 'b list) PMap.t tgroup_join key2 associates to every element x of the first collection, all the elements y of the second collection such that eq x (key y)
val product : 'a collection t -> 'b collection t -> ('a * 'b) collection tCartesian product
val append : 'a collection t -> 'a collection t -> 'a collection tAppend two collections together
val inter :
?cmp:'a ord ->
?eq:'a equal ->
?hash:'a hash ->
unit ->
'a collection t ->
'a collection t ->
'a collection tIntersection of two collections. Each element will occur at most once in the result
val union :
?cmp:'a ord ->
?eq:'a equal ->
?hash:'a hash ->
unit ->
'a collection t ->
'a collection t ->
'a collection tUnion of two collections. Each element will occur at most once in the result
val diff :
?cmp:'a ord ->
?eq:'a equal ->
?hash:'a hash ->
unit ->
'a collection t ->
'a collection t ->
'a collection tSet difference
Specialized projection operators
val fst : ('a * 'b) collection t -> 'a collection tval snd : ('a * 'b) collection t -> 'b collection tval map1 : ('a -> 'b) -> ('a * 'c) collection t -> ('b * 'c) collection tval map2 : ('a -> 'b) -> ('c * 'a) collection t -> ('c * 'b) collection tval flatten_opt : 'a option collection t -> 'a collection tFlatten the collection by removing options
Careful, those operators do not allow any optimization before running the query, they might therefore be pretty slow.
Use the result of a query to build another query and imediately run it.
PMap results directly, rather than collections of elements
Catch errors within the execution itself. In other words, run (catch q) with succeed with x if q succeeds with `Ok x, and fail if q succeeds with `Error s or if q fails
val to_array : 'a collection t -> 'a array tBuild an array of results
val to_seq : 'a collection t -> 'a sequence tBuild a (re-usable) sequence of elements, which can then be converted into other structures
val to_hashtbl : ('a * 'b) collection t -> ('a, 'b) Hashtbl.t tBuild a hashtable from the collection
val to_queue : 'a collection t -> ('a Queue.t -> unit) tval to_stack : 'a collection t -> ('a Stack.t -> unit) tmodule L : sig ... endmodule IO : sig ... end