Documentation

Our representation of a column is a GADT that can store data based on the underlying data.

This allows us to pattern match on data kinds and limit some operations to only some kinds of vectors. E.g. operations for missing data only happen in an OptionalColumn.

A TypedColumn is a wrapper around our type-erased column. It is used to type check expressions on columns.

Gets the underlying value from a TypedColumn.

Checks if a column contains missing values.

Checks if a column contains numeric values.

Checks if a column is of a given type values.

An internal/debugging function to get the column type of a column.

An internal/debugging function to get the type stored in the outermost vector of a column.

A class for converting a vector to a column of the appropriate type. Given each Rep we tell the toColumnRep function which Column type to pick.

Constraint synonym for what we can put into columns.

O(n) Convert a vector to a column. Automatically picks the best representation of a vector to store the underlying data in.

Examples:

> import qualified Data.Vector as V
> fromVector (V.fromList [(1 :: Int), 2, 3, 4])
[1,2,3,4]

O(n) Convert an unboxed vector to a column. This avoids the extra conversion if you already have the data in an unboxed vector.

Examples:

> import qualified Data.Vector.Unboxed as V
> fromUnboxedVector (V.fromList [(1 :: Int), 2, 3, 4])
[1,2,3,4]

O(n) Convert a list to a column. Automatically picks the best representation of a vector to store the underlying data in.

Examples:

> fromList [(1 :: Int), 2, 3, 4]
[1,2,3,4]

An internal function to map a function over the values of a column.

O(1) Gets the number of elements in the column.

O(n) Gets the number of elements in the column.

O(n) Takes the first n values of a column.

O(n) Takes the last n values of a column.

O(n) Takes n values after a given column index.

O(n) Selects the elements at a given set of indices. May change the order.

O(n) Selects the elements at a given set of indices. Does not change the order.

Internal helper to get indices in a boxed vector.

Internal helper to get indices in an unboxed vector.

An internal function that returns a vector of how indexes change after a column is sorted.

Applies a function that returns an unboxed result to an unboxed vector, storing the result in a column.

Filter column with index.

Fold (right) column with index.

Fold (left) column with index.

Generic reduce function for all Column types.

An internal, column version of zip.

An internal, column version of zipWith.

Fills the end of a column, up to n, with Nothing. Does nothing if column has length greater than n.

Fills the beginning of a column, up to n, with Nothing. Does nothing if column has length greater than n.

Concatenates two columns. Returns Nothing if the columns are of different types.

Concatenates two columns.

Works similar to concatColumns, but unlike that function, it will also combine columns of different types by wrapping the values in an Either.

E.g. combining Column containing [1,2] with Column containing ["a","b"] will result in a Column containing [Left 1, Left 2, Right "a", Right "b"].

O(n) Converts a column to a list. Throws an exception if the wrong type is specified.

Examples:

> column = fromList [(1 :: Int), 2, 3, 4]
> toList Int column
[1,2,3,4]
> toList Double column
exception: ...

A safe version of toVector that returns an Either type.