A phantom-typed wrapper over the untyped DataFrame.

The type parameter cols is a type-level list of Column name ty entries that tracks the schema at compile time. All operations delegate to the untyped core at runtime and update the phantom type at compile time.

A phantom type that pairs a type-level column name (Symbol) with its element type. Has no value-level constructors — used purely at the type level to describe schemas.

A phantom-typed wrapper over GroupedDataFrame.

The These type represents values with two non-exclusive possibilities.

This can be useful to represent combinations of two values, where the combination is defined if either input is. Algebraically, the type These A B represents (A + B + AB), which doesn't factor easily into sums and products--a type like Either A (B, Maybe A) is unclear and awkward to use.

These has straightforward instances of Functor, Monad, &c., and behaves like a hybrid error/writer monad, as would be expected.

For zipping and unzipping of structures with These values, see Data.Align.

A typed expression validated against schema cols, producing values of type a.

Unlike the untyped 'Expr a', a TExpr can only be constructed through type-safe combinators (col, lit, arithmetic operations) that verify column references exist in the schema with the correct type.

Use unTExpr to extract the underlying Expr for delegation to the untyped API.

Create a typed column reference. This is the key type-safety entry point.

The column name must exist in cols and its type must match a. Both checks happen at compile time via type families.

salary :: TExpr '[Column "salary" Double] Double
salary = col @"salary"

Create a literal expression. Valid for any schema since it references no columns.

Conditional expression.

Lift a unary function into a typed expression.

Lift a binary function into typed expressions.

A typed sort order validated against schema cols.

Create an ascending sort order from a typed expression.

Create a descending sort order from a typed expression.

Create a NamedExpr for use with aggregateUntyped.

Validate that an untyped DataFrame matches the expected schema cols, then wrap it. Returns Nothing on mismatch.

Like freeze but returns a descriptive error message on failure.

Unwrap a typed DataFrame back to the untyped representation. Always safe; discards type information.

Wrap an untyped DataFrame without any validation. Used internally after delegation where the library guarantees schema correctness.

Retrieve a column as a boxed Vector, with the type determined by the schema. The column must exist (enforced at compile time).

Retrieve a column as a list, with the type determined by the schema.

Filter rows where a boolean expression evaluates to True. The expression is validated against the schema at compile time.

Filter rows by applying a predicate to a typed expression.

Filter rows by a predicate on a column expression (flipped argument order).

Keep only rows where ALL Optional columns have Just values. Strips Maybe from all column types in the result schema.

df :: TDF '[Column "x" (Maybe Double), Column "y" Int]
filterAllJust df :: TDF '[Column "x" Double, Column "y" Int]

Keep only rows where the named column has Just values. Strips Maybe from that column's type in the result schema.

filterJust @"x" df

Keep only rows where the named column has Nothing. Schema is preserved (column types unchanged, just fewer rows).

Sort by the given typed sort orders. Sort orders reference columns that are validated against the schema.

Take the first n rows.

Take the last n rows.

Drop the first n rows.

Drop the last n rows.

Take rows in the given range (start, end).

Take a sub-cube of the DataFrame.

Remove duplicate rows.

Randomly sample a fraction of rows.

Shuffle all rows randomly.

Derive a new column from a typed expression. The column name must NOT already exist in the schema (enforced at compile time via AssertAbsent). The expression is validated against the current schema.

df' = derive @"total" (col @"price" * col @"qty") df
-- df' :: TDF (Column "total" Double ': originalCols)

Select a subset of columns by name.

Exclude columns by name.

Rename a column.

Rename multiple columns from a type-level list of pairs.

Insert a new column from a Foldable container.

Insert a raw Column value.

Insert a boxed Vector.

Clone an existing column under a new name.

Drop a column by name.

Replace an existing column with new values derived from a typed expression. The column must already exist and the new type must match.

Vertically merge two DataFrames with the same schema.

Typed inner join on one or more key columns.

Typed left join.

Typed right join.

Typed full outer join.

Group a typed DataFrame by one or more key columns.

grouped = groupBy @'["department"] employees

Add one aggregation to the builder.

Each call prepends a Column name a to the result schema and records the runtime NamedExpr. The expression is validated against the source schema cols at compile time.

agg @"total_sales" (tsum (col @"salary"))
  $ agg @"avg_price" (tmean (col @"price"))
  $ aggNil

The empty aggregation — no output columns beyond the group keys.

Run a typed aggregation.

Result schema = grouping key columns ++ aggregated columns (in declaration order).

result = aggregate
    (agg @"total" (tsum (col "salary")) $ agg @"count" (tcount (col "salary") $ aggNil)
    (groupBy @'["dept"] employees)
-- result :: TDF '[Column "dept" Text, Column "total" Double, Column "count" Int]

Escape hatch: run an untyped aggregation and return a raw DataFrame.

Look up the element type of a column by name.

Check whether a column name exists in a schema (type-level Bool).

Select a subset of columns by a list of names.

Exclude columns by a list of names.

Rename a column in the schema.

Remove a column by name from a schema.

Unwrap a Maybe from a type after we impute values.

Append two type-level lists.

Reverse a type-level list.

Strip Maybe from all columns. Used by filterAllJust.

Column "x" (Maybe Double) becomes Column "x" Double. Column "y" Int stays Column "y" Int.

Strip Maybe from a single named column. Used by filterJust.

StripMaybeAt "x" '[Column "x" (Maybe Double), Column "y" Int] = '[Column "x" Double, Column "y" Int]

Extract Column entries from a schema whose names appear in keys.

Inner join result schema.

Left join result schema.

Right join result schema.

Full outer join result schema.

Assert that a column name is absent from the schema (for derive/insert).

Assert that a column name is present in the schema.

Assert that a column name is present in the schema.

Provides runtime evidence of a schema: a list of (name, TypeRep) pairs.

A class that provides a list of Text values for a type-level list of Symbols.