Reference

apply(x, f)

Apply the function f to each element of x and return an array.

apply(d::Dict, f)

Apply the function f to each value of d and return a dictionary with the same keys of d.

apply_dfc(x, f)

Apply the function f to each element of x and bind all the columns into a dataframe.

walk2(x, y, f)

The same as apply2(x, y, f) but returns nothing.

discard(x, p)

Discard the elements x_i of collection x such that p(x_i) is true.

keep(x, p)

Keep the elements x_i of collection x such that p(x_i) is true.

has_element(x, y)

Returns true if y is an element of x.

negate(f)

Return a function which is the negation of f.

flatten_dfr_json(dicts::Vector{<:Dict}, n::Int = 1)

Given a vector of dictionaries, flatten each of them and concatenate on a dataframe; remaining vectors and dictionaries are converted to a json string.

is_non_empty(x)

Check if a object has length greater than 0.

compact(x)

Keep the elements x_i of collection x such that is_non_empty(x_i) is true.

discard!(x, p)

Discard the elements x_i of collection x such that p(x_i) is true.

apply_dfr(x, f)

Apply the function f to each element of x and bind all the rows into a dataframe.

modify_if!(x, f, p)

Modify x applying f to each of its elements where the function p is true.

flatten_dfr(dicts::Vector{<:Dict}, n::Int = 1)

Given a vector of dictionaries, flatten each of them and concatenate on a dataframe.

json_string(x)

Convert x to a JSON string.

compact!(x)

Keep the elements x_i of collection x such that is_non_empty(x_i) is true.

pwalk(x, f)

The same as papply(x, f) but returns nothing.

detect_index(x, p)

Returns the index for the first element of x where p is true.

some(x, p)

Do some x_i in x satisfies p?

apply_keys(d::Dict, f)

Apply the function f to each key of d and return a dictionary with the same values of d.

iapply(x, f)

Apply the function f to each pair (i, x_i) for i in the index set of x.

iapply(d::Dict, f)

Apply the function f to each pair (k, d[k]) for k in the values-set of d.

apply2(x, y, f)

Apply the 2-variable function f to each element pair (x_i, y_i) where x_i (resp. y_i) is the i-th element of x (resp. y).

apply2(d1::Dict, d2::Dict, f)

The same as Dict(k => f(d1[k], d2[k]) for k ∈ keys(d1) ∩ keys(d2)), that is: we apply f on (d1[k], d2[k]) for every k common key between d1 and d2.

modify!(x, f)

Modify x applying f to each of its elements.

is_empty(x)

Check if a object has length 0.

detect(x, p)

Returns the first element of x where p is true.

walk(x, f)

The same as apply(x, f) but returns nothing.

iwalk(x, f)

The same as iapply(x, f) but returns nothing.

keep!(x, p)

Keep the elements x_i of collection x such that p(x_i) is true.

none(x, p)

Do none x_i in x satisfies p?

has_key(d, k)

Returns true if the dictionary d has key k.

flatten_dict(key, value)

Transform a pair key and value into a dictionary.

flatten_dict(key, value:: Dict{<:Any, <:Any})

Given a key and a value which is a dictionary, concatenate the key string to every other key of the dictionary value. A dictionary of dictionaries will become only a dictionary of values.

flatten_dict(dict::Dict{<:Any, <:Any}, n = 1)

Remove one layer of dictionaries of a dictionary.

possibly(f, otherwise = nothing)

Create a modified version of the function f such that it returns otherwise when f(x) throws an error.

modify(x, f)

Modify a copy of x applying f to each of its elements.

compose(args…)

Create the composite function of the args....

get_value(d, k, v = nothing)

Try to get the value d[k], it it exists. Otherwise, return v.

papply(x, f)

Apply the function f to each element of x. This is a generalization of apply2.

compose_n(f, n = 2)

Compose the function f with itself n times.

every(x, p)

Do every x_i in x satisfies p?

modify_if(x, f, p)

Modify a copy of x applying f to each of its elements where the function p is true.