DataFrame Module

DataFrame.readCsv

String -> Result DataFrame DataFrameError

import DataFrame

// Local file
DataFrame.readCsv "data.csv"

// Remote file
DataFrame.readCsv "https://example.com/data.csv"

Notes: With a string literal path, column names and types are validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readCsvColumns, DataFrame.readJson, DataFrame.readParquet

DataFrame.readCsvColumns

[DataFrameColumn] -> String -> Result DataFrame DataFrameError

import DataFrame

DataFrame.readCsvColumns [@name, @age] "data.csv"
DataFrame.readCsvColumns [@name, @age] "https://example.com/data.csv"

Notes: Column projection is applied at the I/O level for efficient reading. With literal path and columns, validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readCsv

DataFrame.readJson

String -> Result DataFrame DataFrameError

import DataFrame

-- Local file
DataFrame.readJson "data.json"

-- Remote file
DataFrame.readJson "https://example.com/data.json"

Notes: With a string literal path, column names and types are validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readJsonColumns, DataFrame.readJsonl, DataFrame.readCsv

DataFrame.readJsonColumns

[DataFrameColumn] -> String -> Result DataFrame DataFrameError

import DataFrame

DataFrame.readJsonColumns [@x, @y] "data.json"
DataFrame.readJsonColumns [@x, @y] "https://example.com/data.json"

Notes: Reads full file then selects columns. With literal path and columns, validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readJson

DataFrame.readJsonl

String -> Result DataFrame DataFrameError

import DataFrame

-- Local file
DataFrame.readJsonl "events.jsonl"

-- Remote file
DataFrame.readJsonl "https://example.com/events.jsonl"

Notes: With a string literal path, column names and types are validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory). Use readJson for JSON array files ([{...}, ...]); use readJsonl for NDJSON files where each line is an independent JSON object.

Struct flattening: Nested JSON object columns are automatically expanded into _-separated top-level columns after reading. For example, a column address: {city, zip} becomes @address_city and @address_zip. This matches Jsonl.parseDataFrame behaviour. List<Struct> columns (arrays of objects) are not flattened — they remain as list columns.

Memory warning: Files with deeply nested columns (e.g. a column that is a list of structs with variable keys) can cause very large transient memory allocations during parsing — potentially many times the file size — because Polars materialises the full Arrow representation of every nested value in memory before returning. If your file has such columns and you do not need them, use readJsonlColumns to select only the flat scalar columns you need. This avoids parsing the heavy nested fields entirely.

See also: DataFrame.readJsonlColumns, DataFrame.readJson, DataFrame.readCsv

DataFrame.readJsonlColumns

[DataFrameColumn] -> String -> Result DataFrame DataFrameError

import DataFrame

DataFrame.readJsonlColumns [@id, @timestamp, @value] "events.jsonl"
DataFrame.readJsonlColumns [@id, @timestamp, @value] "https://example.com/events.jsonl"

Notes: Unselected columns — including large nested fields — are never parsed. The reader infers the full schema from the first 100 rows, builds a subset schema containing only the requested columns, and passes it to the NDJSON byte-level reader so that simd-json never allocates Arrow buffers for the skipped fields. On files with heavy List<Struct> columns this can reduce peak memory from tens of GB to a few hundred MB.

Column name forms: Selected column names may be literal top-level field names (@address) or flattened sub-field names (@address_city). A literal struct name expands to all its sub-columns after flattening (e.g. @address yields @address_city and @address_zip). A flattened sub-field name resolves back to the ancestor struct, which is loaded and then trimmed to only the requested sub-column. List<Struct> columns (arrays of objects) are left as-is and must be named by their literal top-level key.

With literal path and columns, validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readJsonl, DataFrame.readJsonColumns

DataFrame.readParquet

String -> Result DataFrame DataFrameError

import DataFrame

// Local file
DataFrame.readParquet "data.parquet"

// Remote file
DataFrame.readParquet "https://example.com/data.parquet"

Notes: With a string literal path, column names and types are validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readParquetColumns, DataFrame.readCsv

DataFrame.readParquetColumns

[DataFrameColumn] -> String -> Result DataFrame DataFrameError

import DataFrame

DataFrame.readParquetColumns [@id, @score] "data.parquet"
DataFrame.readParquetColumns ["id", "score"] "https://example.com/data.parquet"

Notes: True columnar projection — unneeded columns are never read from disk. With literal path and columns, validated at compile time. Remote URLs require KEEL_HTTP_DISABLED=0. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readParquet

DataFrame.readDta

String -> Result DataFrame DataFrameError

import DataFrame
DataFrame.readDta "data.dta"

Notes: Preserves variable labels, value labels, and dataset label as metadata. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readDtaColumns, DataFrame.writeDta, DataFrame.readCsv

DataFrame.readDtaColumns

[DataFrameColumn] -> String -> Result DataFrame DataFrameError

import DataFrame
DataFrame.readDtaColumns ["var1", "var2"] "data.dta"

Notes: Reads full file then selects columns. With literal path and columns, validated at compile time. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readDta

DataFrame.writeCsv

String -> DataFrame -> Result Unit DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }]

df
    |> DataFrame.writeCsv "out.csv"

Notes: File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.writeJson

DataFrame.writeJson

String -> DataFrame -> Result Unit DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }]

df
    |> DataFrame.writeJson "out.json"

Notes: File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.writeCsv

DataFrame.writeParquet

String -> DataFrame -> Result Unit DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }]

df
    |> DataFrame.writeParquet "data.parquet"

Notes: Metadata is persisted in the Parquet file and restored by readParquet. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readParquet, DataFrame.writeCsv

DataFrame.writeDta

String -> DataFrame -> Result Unit DataFrameError

import DataFrame
let df = DataFrame.fromRecords [{ name = "Alice" }]
df |> DataFrame.writeDta "data.dta"

Notes: Preserves variable labels, value labels, and dataset label from metadata. File paths use two-mode resolution: a path starting with ./ or ../ resolves relative to the calling file; a bare path resolves from the project root (keel.toml directory).

See also: DataFrame.readDta, DataFrame.writeCsv

DataFrame.select

[DataFrameColumn] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice", age = 30 }, { name = "Bob", age = 25 }]

df
    |> DataFrame.select [@name, @age]

Notes: Column names are strings ("name") or column literals (@name). Column names are validated at compile time on typed DataFrames. The resulting DataFrame's type is narrowed to only the selected columns.

See also: DataFrame.remove, DataFrame.columns

DataFrame.remove

[DataFrameColumn] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ id = 1, name = "Alice" }, { id = 2, name = "Bob" }]

df
    |> DataFrame.remove [@id]

Notes: Column names are strings ("name") or column literals (@name). Column names are validated at compile time on typed DataFrames. The resulting DataFrame's type excludes the removed columns.

See also: DataFrame.select

DataFrame.rename

DataFrameColumn -> String -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ old = 1 }, { old = 2 }]

df
    |> DataFrame.rename @old "new"

Notes: Column names are strings ("name") or column literals (@name). The old column name is validated at compile time on typed DataFrames. The resulting DataFrame's type reflects the rename.

DataFrame.applyExprs

[(DataFrameColumn, Expr)] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df = DataFrame.fromRecords [{ price = 10, quantity = 3 }]

-- Update an existing column and add a new column in one call
df |> DataFrame.applyExprs [(@price, @price * 2), (@total, @price * @quantity)]

Notes: Cross-expression dependencies (where one expression references a column produced by an earlier expression in the same list) are handled automatically by batching into sequential Polars passes.

See also: DataFrame.agg

DataFrame.column

DataFrameColumn -> DataFrame -> Result [Maybe a] DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]

case DataFrame.column @name df of
    Ok values -> values
    Err _ -> []

Notes: Column name as a string ("name") or column literal (@name). Every value is wrapped in Maybe since DataFrame columns are nullable. On typed DataFrames the column name is validated at compile time. On untyped DataFrames a missing column returns Err(DataFrameError::ColumnNotFound).

See also: DataFrame.columns

DataFrame.columns

DataFrame -> [String]

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice", age = 30 }]

DataFrame.columns df

See also: DataFrame.dtypes

DataFrame.dtypes

DataFrame -> [(String, String)]

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice", age = 30 }]

DataFrame.dtypes df

See also: DataFrame.columns

DataFrame.checkSchema

SchemaType -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

type InputSchema = { id: Int, amount: Float, .. }

let df = DataFrame.fromRecords [{ id = 1, amount = 9.99 }]
DataFrame.checkSchema "InputSchema" df

Notes: The schema name must be passed as a string literal (e.g. "MySchema"). Enum-backed columns are matched against their underlying primitive type (Int or String). SchemaMismatch details list all failing columns with expected vs. actual types.

See also: DataFrame.dtypes, DataFrame.columns, DataFrame.shape

DataFrame.head

Int -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]

df
    |> DataFrame.head 10

See also: DataFrame.tail, DataFrame.slice

DataFrame.tail

Int -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]

df
    |> DataFrame.tail 5

See also: DataFrame.head

DataFrame.slice

Int -> Int -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]

df
    |> DataFrame.slice 0 1

See also: DataFrame.head, DataFrame.tail

DataFrame.sort

[DataFrameColumn] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Bob", age = 30 }, { name = "Alice", age = 25 }]

df
    |> DataFrame.sort [@name, @age]

Notes: Column names are strings ("name") or column literals (@name). Column names are validated at compile time on typed DataFrames. Returns Result rather than a bare DataFrame because Polars can reject a sort at runtime for reasons beyond column existence — for example, sorting a column whose element type does not implement a total order (such as a nested list column). This failure is not preventable at compile time even on a fully typed DataFrame.

See also: DataFrame.sortDesc

DataFrame.sortDesc

[DataFrameColumn] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ salary = 50000 }, { salary = 70000 }]

df
    |> DataFrame.sortDesc [@salary]

Notes: Column names are strings ("name") or column literals (@name). Column names are validated at compile time on typed DataFrames. Returns Result rather than a bare DataFrame because Polars can reject a sort at runtime for reasons beyond column existence — for example, sorting a column whose element type does not implement a total order (such as a nested list column). This failure is not preventable at compile time even on a fully typed DataFrame.

See also: DataFrame.sort

DataFrame.unique

[DataFrameColumn] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Alice" }, { name = "Bob" }]

df
    |> DataFrame.unique [@name]

Notes: Column names are validated at compile time on typed DataFrames. Returns Result rather than a bare DataFrame because Polars deduplication can fail at runtime when a column contains a type that does not support equality comparison (such as a floating-point column with NaN values in certain configurations). This failure is not preventable at compile time even on a fully typed DataFrame.

DataFrame.sample

Int -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]

df
    |> DataFrame.sample 1

See also: DataFrame.head

DataFrame.filter

Expr -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
import DataFrame.Expr exposing col, lit
import DataFrame.Expr as Expr

let df = DataFrame.fromRecords [{ x = 1 }, { x = 5 }, { x = 10 }]

df
    |> DataFrame.filter (@x |> Expr.gt (lit 2))

Notes: This is the recommended way to filter DataFrames. The expression always compiles to Polars for optimal performance.

See also: DataFrame.Expr.col, DataFrame.Expr.gt

DataFrame.groupBy

[DataFrameColumn] -> DataFrame -> GroupedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ department = "Sales", salary = 50000 }, { department = "Sales", salary = 60000 }]

df
    |> DataFrame.groupBy [@department]

Notes: Returns a GroupedDataFrame. Use DataFrame.agg to aggregate.

See also: DataFrame.agg

DataFrame.agg

[Expr] -> GroupedDataFrame -> DataFrame

import DataFrame
import DataFrame.Expr exposing col
import DataFrame.Expr as Expr

let df = DataFrame.fromRecords [{ group = "A", value = 10 }, { group = "A", value = 20 }, { group = "B", value = 30 }]
let totalExpr = @value |> Expr.sum |> Expr.named "total"
let avgExpr = @value |> Expr.mean |> Expr.named "average"

df |> DataFrame.groupBy [@group] |> DataFrame.agg [totalExpr, avgExpr]

Notes: Each expression should have an alias set using Expr.named. This defines the output column name.

See also: DataFrame.groupBy, DataFrame.Expr.sum

DataFrame.count

DataFrame -> Int

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]

DataFrame.count df

See also: DataFrame.shape

DataFrame.summary

DataFrame -> DataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice", age = 30 }, { name = "Bob", age = 25 }]

DataFrame.summary df

Notes: std and var use Bessel's correction (ddof=1). Quantiles use linear interpolation.

See also: DataFrame.mean, DataFrame.std, DataFrame.median, DataFrame.quantile, DataFrame.quantiles

DataFrame.mean

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ v = 10 }, { v = 20 }, { v = 30 }]
df |> DataFrame.mean

Notes: Non-numeric columns are excluded. Uses all rows.

See also: DataFrame.median, DataFrame.std, DataFrame.summary

DataFrame.median

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ v = 1 }, { v = 3 }, { v = 2 }]
df |> DataFrame.median

Notes: Non-numeric columns are excluded.

See also: DataFrame.mean, DataFrame.quantile

DataFrame.std

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ v = 2 }, { v = 4 }, { v = 6 }]
df |> DataFrame.std

Notes: Uses Bessel's correction (ddof=1). Non-numeric columns are excluded.

See also: DataFrame.var, DataFrame.mean

DataFrame.var

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ v = 2 }, { v = 4 }, { v = 6 }]
df |> DataFrame.var

Notes: Uses Bessel's correction (ddof=1). Non-numeric columns are excluded.

See also: DataFrame.std, DataFrame.mean

DataFrame.mode

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ g = "A" }, { g = "A" }, { g = "B" }]
df |> DataFrame.mode

Notes: Operates on all columns, including non-numeric.

See also: DataFrame.mean, DataFrame.median

DataFrame.quantile

Float -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
let df = DataFrame.fromRecords [{ v = 1 }, { v = 2 }, { v = 3 }, { v = 4 }]
df |> DataFrame.quantile 0.75

Notes: Uses linear interpolation. Non-numeric columns are excluded. Returns InvalidArgument error if p is outside [0.0, 1.0].

See also: DataFrame.median, DataFrame.summary, DataFrame.quantiles

DataFrame.corr

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ x = 1, y = 2 }, { x = 2, y = 4 }, { x = 3, y = 6 }]
df |> DataFrame.corr

Notes: Diagonal values are 1.0. Non-numeric columns are excluded.

See also: DataFrame.cov, DataFrame.std, DataFrame.corrSpearman

DataFrame.cov

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ x = 1, y = 2 }, { x = 2, y = 4 }, { x = 3, y = 6 }]
df |> DataFrame.cov

Notes: Uses Bessel's correction (ddof=1). Non-numeric columns are excluded.

See also: DataFrame.corr, DataFrame.var

DataFrame.partitionBy

[DataFrameColumn] -> DataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ department = "Sales", salary = 50000 }, { department = "HR", salary = 60000 }]

df
    |> DataFrame.partitionBy [@department]

Notes: Column names are strings ("name") or column literals (@name). Partition columns define independent groups for window calculations. Chain with orderBy, ranking, lag/lead, rolling, or cumulative functions.

See also: DataFrame.orderBy, DataFrame.collect

DataFrame.orderBy

[DataFrameColumn] -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1 }, { dept = "Sales", date = 2 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]

Notes: Column names are strings ("name") or column literals (@name). Ordering determines how rows are sequenced within each partition. Must be called before withRank, withDenseRank, withLag, withLead, or rolling functions.

See also: DataFrame.partitionBy, DataFrame.withRank

DataFrame.collect

WindowedDataFrame -> DataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", val = 1 }, { dept = "Sales", val = 2 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.withRowNumber "row_num"
    |> DataFrame.collect

Notes: Must be called at the end of a window function chain to produce a usable DataFrame.

See also: DataFrame.partitionBy

DataFrame.withRowNumber

String -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", val = 1 }, { dept = "Sales", val = 2 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.withRowNumber "row_num"
    |> DataFrame.collect

Notes: Argument is the name of the new column (symbol or string). Row numbers start at 1. Does not require orderBy.

See also: DataFrame.withRank, DataFrame.withDenseRank

DataFrame.withRank

String -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", score = 90 }, { dept = "Sales", score = 85 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@score]
    |> DataFrame.withRank "rank"
    |> DataFrame.collect

Notes: Argument is the name of the new column (symbol or string). Requires orderBy to be set first.

See also: DataFrame.withDenseRank, DataFrame.withRowNumber, DataFrame.orderBy

DataFrame.withDenseRank

String -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", score = 90 }, { dept = "Sales", score = 85 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@score]
    |> DataFrame.withDenseRank "dense_rank"
    |> DataFrame.collect

Notes: Argument is the name of the new column (symbol or string). Requires orderBy to be set first.

See also: DataFrame.withRank, DataFrame.withRowNumber, DataFrame.orderBy

DataFrame.withLag

String -> DataFrameColumn -> Int -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withLag "prev_sales" @sales 1
    |> DataFrame.collect

Notes: Args: new column name, source column, offset (number of rows back). Column names are strings ("name") or column literals (@name). Produces Nothing for rows without a previous value. Requires orderBy.

See also: DataFrame.withLead, DataFrame.orderBy

DataFrame.withLead

String -> DataFrameColumn -> Int -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withLead "next_sales" @sales 1
    |> DataFrame.collect

Notes: Args: new column name, source column, offset (number of rows forward). Column names are strings ("name") or column literals (@name). Produces Nothing for rows without a subsequent value. Requires orderBy.

See also: DataFrame.withLag, DataFrame.orderBy

DataFrame.withRollingSum

String -> DataFrameColumn -> Int -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withRollingSum "sum_3d" @sales 3
    |> DataFrame.collect

Notes: Args: new column name, source column, window size. Column names are strings ("name") or column literals (@name). Window includes the current row and preceding rows. Requires orderBy.

See also: DataFrame.withRollingMean, DataFrame.withCumSum

DataFrame.withRollingMean

String -> DataFrameColumn -> Int -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withRollingMean "avg_3d" @sales 3
    |> DataFrame.collect

Notes: Args: new column name, source column, window size. Column names are strings ("name") or column literals (@name). Window includes the current row and preceding rows. Requires orderBy.

See also: DataFrame.withRollingSum, DataFrame.withCumMean

DataFrame.withRollingMin

String -> DataFrameColumn -> Int -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withRollingMin "min_3d" @sales 3
    |> DataFrame.collect

Notes: Args: new column name, source column, window size. Column names are strings ("name") or column literals (@name). Window includes the current row and preceding rows. Requires orderBy.

See also: DataFrame.withRollingMax, DataFrame.withCumMin

DataFrame.withRollingMax

String -> DataFrameColumn -> Int -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withRollingMax "max_3d" @sales 3
    |> DataFrame.collect

Notes: Args: new column name, source column, window size. Column names are strings ("name") or column literals (@name). Window includes the current row and preceding rows. Requires orderBy.

See also: DataFrame.withRollingMin, DataFrame.withCumMax

DataFrame.withCumSum

String -> DataFrameColumn -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withCumSum "running_total" @sales
    |> DataFrame.collect

Notes: Args: new column name, source column. Column names are strings ("name") or column literals (@name). Computes running total over all preceding rows in the partition.

See also: DataFrame.withCumMean, DataFrame.withRollingSum

DataFrame.withCumMean

String -> DataFrameColumn -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withCumMean "running_avg" @sales
    |> DataFrame.collect

Notes: Args: new column name, source column. Column names are strings ("name") or column literals (@name). Computes running average over all preceding rows in the partition.

See also: DataFrame.withCumSum, DataFrame.withRollingMean

DataFrame.withCumMin

String -> DataFrameColumn -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withCumMin "running_min" @sales
    |> DataFrame.collect

Notes: Args: new column name, source column. Column names are strings ("name") or column literals (@name). Tracks the minimum value seen so far in the partition.

See also: DataFrame.withCumMax, DataFrame.withRollingMin

DataFrame.withCumMax

String -> DataFrameColumn -> WindowedDataFrame -> WindowedDataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ dept = "Sales", date = 1, sales = 100 }, { dept = "Sales", date = 2, sales = 200 }]

df
    |> DataFrame.partitionBy [@dept]
    |> DataFrame.orderBy [@date]
    |> DataFrame.withCumMax "running_max" @sales
    |> DataFrame.collect

Notes: Args: new column name, source column. Column names are strings ("name") or column literals (@name). Tracks the maximum value seen so far in the partition.

See also: DataFrame.withCumMin, DataFrame.withRollingMax

DataFrame.lazy

DataFrame -> LazyFrame

import DataFrame
import DataFrame.Expr exposing col, lit
import DataFrame.Expr as Expr

let df = DataFrame.fromRecords [{ x = 1 }, { x = 5 }, { x = 10 }]

df
    |> DataFrame.lazy
    |> DataFrame.lazyFilter (@x |> Expr.gt (lit 2))
    |> DataFrame.lazyCollect

Notes: LazyFrame enables Polars query optimization: predicate pushdown, projection pushdown, and parallel execution.

See also: DataFrame.lazyCollect, DataFrame.lazyFilter

DataFrame.lazyCollect

LazyFrame -> DataFrame

import DataFrame
DataFrame.fromRecords [{ x = 1 }, { x = 2 }] |> DataFrame.lazy |> DataFrame.lazyCollect

Notes: This triggers the actual computation. Until collect is called, all operations are deferred.

See also: DataFrame.lazy

DataFrame.lazyFilter

Expr -> LazyFrame -> LazyFrame

import DataFrame
import DataFrame.Expr exposing col, lit
import DataFrame.Expr as Expr
let filterExpr = @x |> Expr.gt (lit 5)
DataFrame.fromRecords [{ x = 1 }, { x = 10 }] |> DataFrame.lazy |> DataFrame.lazyFilter filterExpr |> DataFrame.lazyCollect

Notes: The filter is added to the query plan and optimized with other operations.

See also: DataFrame.lazy, DataFrame.filter

DataFrame.lazySelect

[Expr] -> LazyFrame -> LazyFrame

import DataFrame
import DataFrame.Expr exposing col
import DataFrame.Expr as Expr
let yRenamed = @y |> Expr.named "y_renamed"
DataFrame.fromRecords [{ x = 1, y = 2 }] |> DataFrame.lazy |> DataFrame.lazySelect [yRenamed] |> DataFrame.lazyCollect

Notes: Enables projection pushdown - only selected columns are read from files.

See also: DataFrame.lazy, DataFrame.select

DataFrame.lazyApplyExprs

[Expr] -> LazyFrame -> LazyFrame

import DataFrame
import DataFrame.Expr exposing col, lit
import DataFrame.Expr as Expr
let doubledExpr = @x |> Expr.mul (lit 2) |> Expr.named "x_doubled"
DataFrame.fromRecords [{ x = 5 }] |> DataFrame.lazy |> DataFrame.lazyApplyExprs [doubledExpr] |> DataFrame.lazyCollect

Notes: Each expression should have an alias set using Expr.named.

See also: DataFrame.lazy, DataFrame.applyExprs

DataFrame.join

[DataFrameColumn] -> [DataFrameColumn] -> JoinType -> DataFrame -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let users =
    DataFrame.fromRecords
        [ { id = 1, name = "Alice" }
        , { id = 2, name = "Bob" }
        ]

let roles =
    DataFrame.fromRecords
        [ { user_id = 1, role = "admin" }
        , { user_id = 2, role = "viewer" }
        ]

-- OneToOne: each user_id appears exactly once on both sides
users
    |> DataFrame.join [@id] [@user_id] JoinType::OneToOne roles

-- Multi-column join: match on both country and year
let pop =
    DataFrame.fromRecords
        [ { country = "DE", year = 2020, population = 83000000 }
        ]

let gdp =
    DataFrame.fromRecords
        [ { country = "DE", year = 2020, gdp = 3800000000000 }
        ]

pop
    |> DataFrame.join [@country, @year] [@country, @year] JoinType::OneToOne gdp

Notes: Pass column names as column literals ([@id]) or string lists (["id"]). For single-column joins use a one-element list: [@id]. JoinType is available after import DataFrame.

See also: DataFrame.concat

DataFrame.concat

[DataFrame] -> Result DataFrame DataFrameError

import DataFrame

let df1 =
    DataFrame.fromRecords [{ name = "Alice" }]

let df2 =
    DataFrame.fromRecords [{ name = "Bob" }]

DataFrame.concat [df1, df2]

See also: DataFrame.join

DataFrame.pivot

DataFrameColumn -> DataFrameColumn -> DataFrameColumn -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let df =
    DataFrame.fromRecords [{ category = "A", date = "Jan", amount = 100 }, { category = "B", date = "Jan", amount = 200 }]

df
    |> DataFrame.pivot @category @date @amount

Notes: Args: on, index, values. Column names are strings ("name") or column literals (@name).

DataFrame.toRecords

DataFrame -> [Record]

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice", age = 30 }]

DataFrame.toRecords df

Notes: Each row becomes a record with column names as field names.

See also: DataFrame.fromRecords

DataFrame.fromRecords

[Record] -> DataFrame

import DataFrame

-- Inline record list
DataFrame.fromRecords [{ name = "Alice", age = 30 }]

-- Named schema via type alias — recommended for multi-field records
type alias Row = { name : String, age : Int }
let rows : [Row] = [{ name = "Alice", age = 30 }, { name = "Bob", age = 25 }]
DataFrame.fromRecords rows

Notes: All records should have the same fields. Use type alias to name a reusable row schema.

See also: DataFrame.toRecords

DataFrame.fromLists

[(String, [a])] -> DataFrame

import DataFrame

DataFrame.fromLists [("age", [30, 40]), ("name", ["Alice", "Bob"])]

Notes: Column-oriented data construction. All value lists must have the same length. Supports Maybe-wrapped values. Composes well with List.zip for programmatic column creation. For single-column DataFrames, pass a single-element list: [("col", [values])].

See also: DataFrame.fromRecords

DataFrame.recode

DataFrameColumn -> [(Int, Int)] -> DataFrame -> DataFrame

import DataFrame
import ValueLabelSet

let labels = ValueLabelSet.fromList [(1, "Low"), (2, "Medium"), (3, "High")]
let df = (DataFrame.fromRecords [{ score = 1 }, { score = 2 }, { score = 3 }]
    |> DataFrame.setValueLabels @score labels)?

-- Collapse categories: 1 stays 1, 2->1, 3->2
df |> DataFrame.recode @score [(2, 1), (3, 2)]
-- Labels are automatically remapped: 1->"Low", 2->"High"

Notes: Value labels are automatically updated based on the recode mapping. Values not in the mapping remain unchanged.

See also: DataFrame.setValueLabels

DataFrame.shape

DataFrame -> (Int, Int)

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice", age = 30 }]

DataFrame.shape df

See also: DataFrame.count, DataFrame.columns

DataFrame.setMeta

String -> a -> DataFrame -> DataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ x = 1 }]

df
    |> DataFrame.setMeta "name" "PISA 2022"

Notes: Metadata values can be String, Int, Float, Bool, List, or Record.

See also: DataFrame.meta, DataFrame.allMeta

DataFrame.meta

String -> DataFrame -> Maybe a

import DataFrame

DataFrame.fromRecords [{ x = 1 }]
    |> DataFrame.setMeta "name" "test"
    |> DataFrame.meta "name"

See also: DataFrame.setMeta, DataFrame.allMeta

DataFrame.allMeta

DataFrame -> Record

import DataFrame

let df =
    DataFrame.fromRecords [{ x = 1 }]

DataFrame.allMeta df

See also: DataFrame.meta, DataFrame.setMeta

DataFrame.setColumnMeta

DataFrameColumn -> String -> a -> DataFrame -> DataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ score = 500 }]

df
    |> DataFrame.setColumnMeta @score "label" "Math score"

Notes: First arg is column name (symbol or string), second is metadata key.

See also: DataFrame.columnMeta, DataFrame.allColumnMeta

DataFrame.columnMeta

DataFrameColumn -> String -> DataFrame -> Maybe a

import DataFrame

DataFrame.fromRecords [{ score = 500 }]
    |> DataFrame.setColumnMeta @score "label" "Math"
    |> DataFrame.columnMeta @score "label"

See also: DataFrame.setColumnMeta, DataFrame.allColumnMeta

DataFrame.allColumnMeta

DataFrameColumn -> DataFrame -> Record

import DataFrame

let df =
    DataFrame.fromRecords [{ score = 500 }]

DataFrame.allColumnMeta @score df

See also: DataFrame.columnMeta, DataFrame.setColumnMeta

DataFrame.describeMeta

DataFrame -> DataFrame

import DataFrame

let df =
    DataFrame.fromRecords [{ x = 1 }]

DataFrame.describeMeta df

Notes: Returns a DataFrame with columns: level, key, value.

See also: DataFrame.allMeta, DataFrame.allColumnMeta

DataFrame.describe

DataFrame -> DataFrame

import DataFrame
import ValueLabelSet
import Result
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df =
    (DataFrame.fromRecords [{ name = "Alice", gender = 1 }]
        |> DataFrame.setVarLabel @name "Person's name"
        |> Result.andThen (DataFrame.setValueLabels @gender gender))?
DataFrame.describe df

Notes: Returns a DataFrame with columns: name, type, label, values, metadata. Rows are in column order. Value labels show abbreviated form: {1=Male, 2=Female} for ≤5 labels, or "N labels" for more.

See also: DataFrame.describeMeta, DataFrame.describeLabels, DataFrame.varLabels, DataFrame.search

DataFrame.search

String -> DataFrame -> DataFrame

import DataFrame
import ValueLabelSet
import Result
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df =
    (DataFrame.fromRecords [{ name = "Alice", gender = 1, income = 50000 }]
        |> DataFrame.setVarLabel @name "Person's name"
        |> Result.andThen (DataFrame.setVarLabel @income "Annual income in USD")
        |> Result.andThen (DataFrame.setValueLabels @gender gender))?

-- Search by variable name
DataFrame.search "name" df

Notes: Case-insensitive substring search across all variable metadata: name, label (description), value labels, and column metadata. Returns a DataFrame with columns: name, type, label, values, metadata.

See also: DataFrame.describe, DataFrame.describeMeta, DataFrame.varLabels

DataFrame.setVarLabel

DataFrameColumn -> String -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
let df = DataFrame.fromRecords [{ name = "Alice", age = 30 }]
case df |> DataFrame.setVarLabel @name "Person's full name" of
    Ok labeled -> DataFrame.varLabel @name labeled
    Err e -> Nothing

Notes: Variable labels describe what a column represents. They are preserved in STATA files. On typed DataFrames the column name is validated at compile time. On untyped DataFrames a missing column returns Err(DataFrameError::ColumnNotFound).

See also: DataFrame.varLabel, DataFrame.removeVarLabel

DataFrame.varLabel

DataFrameColumn -> DataFrame -> Maybe String

import DataFrame
let df = (DataFrame.fromRecords [{ name = "Alice" }] |> DataFrame.setVarLabel @name "Person's name")?
DataFrame.varLabel @name df  -- Just "Person's name"

See also: DataFrame.setVarLabel, DataFrame.varLabels

DataFrame.varLabels

DataFrame -> { String : String }

import DataFrame
import Result
let df =
    (DataFrame.fromRecords [{ name = "Alice", age = 30 }]
        |> DataFrame.setVarLabel @name "Person's name"
        |> Result.andThen (DataFrame.setVarLabel @age "Age in years"))?
DataFrame.varLabels df  -- { name = "Person's name", age = "Age in years" }

See also: DataFrame.varLabel, DataFrame.setVarLabel

DataFrame.removeVarLabel

DataFrameColumn -> DataFrame -> DataFrame

import DataFrame
let df = (DataFrame.fromRecords [{ name = "Alice" }] |> DataFrame.setVarLabel @name "Person's name")?
df |> DataFrame.removeVarLabel @name

See also: DataFrame.setVarLabel, DataFrame.varLabel

DataFrame.setValueLabels

DataFrameColumn -> ValueLabelSet -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = DataFrame.fromRecords [{ id = 1, gender = 1 }]
case df |> DataFrame.setValueLabels @gender gender of
    Ok labeled -> labeled
    Err e -> df

Notes: Value labels map numeric codes to human-readable labels. Use setValueLabelsStrict for exhaustive validation. Returns Err(DataFrameError::ColumnNotFound) if the column does not exist.

See also: DataFrame.setValueLabelsStrict, DataFrame.valueLabels

DataFrame.setValueLabelsStrict

DataFrameColumn -> ValueLabelSet -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = DataFrame.fromRecords [{ id = 1, gender = 1 }]
case df |> DataFrame.setValueLabelsStrict @gender gender of
    Ok labeled -> labeled
    Err e -> df

Notes: Returns Err(DataFrameError::OperationFailed) if any value in the column lacks a corresponding label. Returns Err(DataFrameError::ColumnNotFound) if the column does not exist.

See also: DataFrame.setValueLabels, DataFrame.valueLabels

DataFrame.valueLabels

DataFrameColumn -> DataFrame -> Maybe ValueLabelSet

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = (DataFrame.fromRecords [{ gender = 1 }] |> DataFrame.setValueLabels @gender gender)?
DataFrame.valueLabels @gender df  -- Just (ValueLabelSet)

See also: DataFrame.setValueLabels, DataFrame.allValueLabels

DataFrame.allValueLabels

DataFrame -> { String : ValueLabelSet }

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = (DataFrame.fromRecords [{ gender = 1 }] |> DataFrame.setValueLabels @gender gender)?
DataFrame.allValueLabels df

See also: DataFrame.valueLabels, DataFrame.setValueLabels

DataFrame.removeValueLabels

DataFrameColumn -> DataFrame -> DataFrame

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = (DataFrame.fromRecords [{ gender = 1 }] |> DataFrame.setValueLabels @gender gender)?
df |> DataFrame.removeValueLabels @gender

See also: DataFrame.setValueLabels, DataFrame.valueLabels

DataFrame.setDisplayMode

DataFrameColumn -> String -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = DataFrame.fromRecords [{ gender = 1 }]
case df |> DataFrame.setValueLabels @gender gender of
    Ok labeled ->
        case labeled |> DataFrame.setDisplayMode @gender "Labeled" of
            Ok final -> final
            Err _ -> labeled
    Err _ -> df

Notes: Display modes: "Raw" shows only the value, "Labeled" shows only the label, "Both" (default) shows "value (label)". Returns Err(DataFrameError::InvalidArgument) if the mode string is not one of these three values.

See also: DataFrame.displayMode, DataFrame.setValueLabels

DataFrame.displayMode

DataFrameColumn -> DataFrame -> String

import DataFrame
let df = DataFrame.fromRecords [{ gender = 1 }]
DataFrame.displayMode @gender df  -- "Both"

Notes: Returns "Both" (the default) if no display mode has been set.

See also: DataFrame.setDisplayMode, DataFrame.setValueLabels

DataFrame.describeLabel

DataFrameColumn -> DataFrame -> String

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = (DataFrame.fromRecords [{ gender = 1 }] |> DataFrame.setValueLabels @gender gender)?
DataFrame.describeLabel @gender df

Notes: Returns a formatted table with Value and Label columns. Returns a message if the column has no value labels.

See also: DataFrame.describeLabels, DataFrame.valueLabels

DataFrame.describeLabels

DataFrame -> String

import DataFrame
import ValueLabelSet
let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
let df = (DataFrame.fromRecords [{ gender = 1 }] |> DataFrame.setValueLabels @gender gender)?
DataFrame.describeLabels df

Notes: Lists all columns with value labels, sorted by column name. Returns "(no value labels)" if none are set.

See also: DataFrame.describeLabel, DataFrame.valueLabels, DataFrame.allValueLabels, DataFrame.describeMeta

DataFrame.lineage

DataFrame -> Record

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }]

df
    |> DataFrame.lineage

Notes: Returns a Record with 'columns' (per-column lineage) and 'globalOperations' (operations affecting all columns).

See also: DataFrame.columnLineage

DataFrame.columnLineage

DataFrameColumn -> DataFrame -> Maybe Record

import DataFrame

let df =
    DataFrame.fromRecords [{ name = "Alice" }]

DataFrame.columnLineage @name df

Notes: Returns Just Record with origin, transformations, and dependencies, or Nothing if column not found.

See also: DataFrame.lineage

DataFrame.sourcePath

DataFrame -> Maybe String

import DataFrame

let df = DataFrame.fromRecords [{ name = "Alice", age = 30 }]
DataFrame.sourcePath df

Notes: Returns Just path for file-sourced DataFrames, Nothing for DataFrames created from records or other sources.

See also: DataFrame.lineage, DataFrame.parents

DataFrame.parents

DataFrame -> [Record]

import DataFrame

let df = DataFrame.fromRecords [{ name = "Alice" }, { name = "Bob" }]
let selected = case (df |> DataFrame.select [@name]) of
    Ok d -> d
    Err _ -> DataFrame.fromRecords []
DataFrame.parents selected

Notes: Returns a list of records with 'id', 'name', and 'operation' fields. Root DataFrames (from file reads or fromRecords) have no parents.

See also: DataFrame.lineage, DataFrame.sourcePath

DataFrame.lineageById

String -> Maybe Record

import DataFrame

-- Look up a DataFrame by its ID (returns Nothing if not found)
DataFrame.lineageById "00000000-0000-0000-0000-000000000000"

Notes: Returns Just Record if a DataFrame with that ID has been created in this session, Nothing otherwise.

See also: DataFrame.lineageByName, DataFrame.lineage

DataFrame.lineageByName

String -> [Record]

import DataFrame

let df = DataFrame.fromRecords [{ x = 1 }, { x = 2 }]
DataFrame.lineageByName "fromRecords"

Notes: Returns a list of lineage records whose display name contains the search string (case-insensitive).

See also: DataFrame.lineageById, DataFrame.lineage

DataFrame._checkSchemaImpl

CheckSchemaSpec -> DataFrame -> Result DataFrame DataFrameError

DataFrame._fromRecordsWithLabels

ValueLabelsMap -> [Record] -> DataFrame

DataFrame.corrSpearman

DataFrame -> DataFrame

import DataFrame
let df = DataFrame.fromRecords [{ x = 1, y = 2 }, { x = 2, y = 4 }, { x = 3, y = 5 }]
df |> DataFrame.corrSpearman

Notes: Diagonal values are 1.0. Non-numeric columns are excluded. NaN values in rank computation are treated as the largest rank value.

See also: DataFrame.corr, DataFrame.cov

DataFrame.melt

[DataFrameColumn] -> [String] -> String -> String -> DataFrame -> Result DataFrame DataFrameError

import DataFrame

let wide =
    DataFrame.fromRecords
        [ { nr = 1, var1_year1 = 10, var1_year2 = 20, var2_year1 = 30, var2_year2 = 40 }
        , { nr = 2, var1_year1 = 50, var1_year2 = 60, var2_year1 = 70, var2_year2 = 80 }
        ]

-- Result: columns nr, year (Int), var1, var2 -- 4 rows
wide |> DataFrame.melt [@nr] ["var1_", "var2_"] "_" "year"

Notes: Stem name is the prefix with the trailing separator stripped ("var1_" → "var1"). Suffix is parsed as Int if all values are numeric, otherwise String.

See also: DataFrame.pivot

DataFrame.quantiles

[Float] -> DataFrame -> Result DataFrame DataFrameError

import DataFrame
let df = DataFrame.fromRecords [{ v = 1 }, { v = 2 }, { v = 3 }, { v = 4 }]
case df |> DataFrame.quantiles [0.25, 0.5, 0.75] of
    Ok q  -> q
    Err _ -> DataFrame.fromRecords []

Notes: Uses linear interpolation. Non-numeric columns are excluded. Quantile rows appear in the same order as the input list; duplicates are preserved.

See also: DataFrame.quantile, DataFrame.median, DataFrame.summary