Index of values

Synonym to OLinq.range

Infix synonym to OLinq.app

Infix version of OLinq.flat_map

Infix synonym of OLinq.map

Apply each function to each value.

Append two collections together

Assuming the json is an object, obtain the given key, otherwise empty

Choose one element (if any, otherwise empty) in the collection.

concat sep q joins all the strings in q together, similar to String.concat sep (run_list q) basically.

contains x q returns true if x is among the elements returned by q.

count c counts how many times each element of the collection occur, and returns pairs of x, count(x)

count_reflect c returns a map from elements of c to the number of time those elements occur.

create ~names () creates a new table with columns labelled with names

Set difference

Remove duplicate elements from the input collection.

Empty collection

If the json is a list, enter each of its element

Filter out values that do not satisfy predicate.

Filter and map elements at once

Use the result of a query to build another query and immediately run it.

map each element to a collection and flatten the result

Same as OLinq.flat_map but using sequences

View a multimap as a collection of individual key/value pairs

View a multimap as a list of individual key/value pairs

Flatten the collection by removing None and mapping Some x to x.

Fold over the collection

Fold on the items of the map

Fold on the items of the multimap

get n tbl gets the n-th row

get_cell i j tbl gets the j-th value of the i-th row

Select a key from a map and wrap into sequence

group_by f takes a collection c as input, and returns a collection of pairs k, l where every element x of l satifies f x = k.

group_by_reflect 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.

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

Same as OLinq.group_join, but reflects the groups as a multimap

init ~names n f makes a table with size rows, each initialized from f

Intersection of two collections.

View a multimap as a proper collection

join key1 key2 ~merge is a binary operation that takes two collections a and b, projects their elements resp.

Convert a string into a collection of lines

Convert each string into a list of lines

init ~names n row makes a table with size rows, all equal to row

Map each value

Transform values

map_assoc f j maps each value of j, assuming j is an `Assoc, and wraps again in an assoc.

map_list f j maps f over each element of j, if j is a list, and replaces each element with the resulting json value, and wraps those again into a json list

Access the column names.

Query that just returns the elements of the list

of_map m yields each binding of m

of_multimap m yields each single binding of m

Query that returns the elements of the given sequence.

Traverse the characters of the string

Evaluate the query and print it line by line on the output

Cartesian product

Synonym to OLinq.return

Push a row into the table

range i j goes from i up to j included

Read the content of the whole channel in (blocking), returning the corresponding string.

Read a whole file (given by name) and return its content as a string

Build a hashtable from the collection

reflect_list q evaluates all values in q and returns a list of all those values.

reflect_seq q evaluates all values in q and returns a sequence of all those values.

Return one value

Reverse relation of the map, as a multimap

Reverse relation of the multimap

Execute the query, possibly returning an error if things go wrong

Run the query and return the only value

unsafe shortcut for OLinq.run_head.

Return first result

Alias to OLinq_table.num_rows

size t returns one value, the number of items returned by t

Sort items by the given comparison function.

sort_by proj c sorts the collection c by projecting elements using proj, then using cmp to order them

subset () a b returns true if all elements of a belong to b

Take at most n elements

Specialized version of OLinq.take that keeps only the first element

Take elements while they satisfy a predicate

Union of two collections.

Join lines together

update build k ~f ~or_ finds the value v associated to k, and maps k to f v.