DSL operator & function catalog

For a category-by-category tour that teaches when to reach for each family, read operators and functions. This page is the flat catalog; that page is the guided walk.

How to read an entry

Each entry names a callable, its parameters, and its return type. A worked entry:

rolling_mean(
  x: Signal,
  periods: Int,
  *,
  min_periods: Optional[Int] = null,
  ignore: "null" | "nan" | "both" = "both",
) -> Signal

Read it this way:

• Qualified name. A callable is either a bare name (rolling_mean, where) or a dotted accessor method (option.iv, bar.close, time.hour). Dotted names group the market and calendar accessors under bar, option, and time.
• The * separator. A bare * in a signature marks the boundary between positional parameters and keyword-only parameters. Parameters before the * (x, periods) may be passed positionally or by name. Parameters after it (min_periods, ignore) must always be named.
• Return type. Every entry returns one of: a Signal, a scalar (the two constants), a config object (SamplingConfig or BucketingConfig), or a Table (ContractTable, BookTable, PositionTable, or LegTable). A standalone signal program must end on a Signal-valued expression.
• Argument order. Positional arguments come before named arguments. Once a named argument appears, every later argument must also be named.

Every code example on this page is a whole runnable program that ends on a Signal:

// 20-day annualized realized volatility
daily_close = bar.close(sampling=sampling(period="day", time="close"))
returns = log_change(daily_close, 1)
rolling_std(returns, 20) * sqrt(252)

Constants

Two scalar constants. Both resolve to their raw numeric value where used; neither is a Signal.

Config & import builders

Three builders. The first two produce config objects consumed by an accessor's sampling= / bucketing= argument; the third imports a saved signal.

sampling(*, period, multiplier, offset, time, times, days, weeks, months) -> SamplingConfig
bucketing(*, period, agg, multiplier, offset, partial) -> BucketingConfig
signal(slug: String) -> Signal

• sampling(...) returns a SamplingConfig for point-in-time sampling.
• bucketing(...) returns a BucketingConfig for window aggregation.
• signal("slug") imports a previously saved signal by its slug and returns its value on the importing program's spine. Writing signal("realized-vol-20d") is equivalent to writing that signal's expression in place.

The two config builders are folded at compile time and are passed to an accessor call, not evaluated on their own. Full parameter tables, the period and time enumerations, and the cascading defaults live in the data accessor reference.

Signal resampling

Two functions apply a config object to an already-computed Signal, the Signal-level counterparts to passing sampling= / bucketing= on an accessor.

sample(x: Signal, sampling: SamplingConfig) -> Signal
bucket(x: Signal, bucketing: BucketingConfig) -> Signal

• sample(x, sampling) applies a SamplingConfig to x: point-in-time selection with backward as-of fill.
• bucket(x, bucketing) applies a BucketingConfig to x: a window aggregate over observed rows, one row per bucket, labeled at the window's right endpoint.

sampling and bucketing are mutually exclusive on a single accessor call. Use sample() / bucket() when the series is a derived expression rather than a raw accessor result.

// Daily close of a derived intraday ratio
ratio = bar.close() / bar.open()
sample(ratio, sampling(period="day", time="close"))

Element-wise transforms

Twenty-five pointwise functions. Each maps input to output row by row; null and NaN propagate unchanged.

Domain errors return NaN rather than raising: sqrt(-1), log(0), and arcsin(2) all produce NaN, as does an overflowing exp.

Most of these take a single argument. The ones that do not:

• root(x, power) takes the root degree as a second positional argument.
• log(x, base) and lognp(x, n, base) take the base as "e", 2, or 10; lognp also takes the offset n (default 1).
• round(x, decimals) takes the decimal count and uses banker's rounding.
• clip(x, lower, upper) raises if lower > upper when both are set.

Missing-data & conditional

Five functions for handling null / NaN and for row-wise selection.

fill_missing(x: Signal, value: Signal, fill: "null" | "nan" | "both" = "nan") -> Signal
coalesce(*args: Signal, exhausted: "null" | "nan" = "null") -> Signal
where(cond: Signal, arg1: Signal, arg2: Signal) -> Signal
is_missing(x: Signal, kind: "null" | "nan" | "both") -> Signal
replace_where(x: Signal, cond: Signal, value: Signal) -> Signal

• fill_missing(x, value, fill) replaces missing observations of x with value. fill selects which kind to target. When value is itself missing at a row, that row is left unchanged.
• coalesce(*args, exhausted) is variadic and takes one or more Signals. It returns the first non-missing value across its arguments, left to right, at each timestamp; exhausted chooses the fallback when every argument is missing at a row.
• is_missing(x, kind) returns Float64 1.0 where x is missing and 0.0 otherwise. The output is never null or NaN.
• replace_where(x, cond, value) returns x with truthy-cond rows replaced by value. A null or NaN in cond keeps the original x at that row.

where(cond, arg1, arg2) is a row-wise select, not a mask. It returns arg1 where cond is truthy (any non-zero value) and arg2 otherwise. Either branch can be any Float64 value, not only 1.0 / 0.0. A null cond yields null; a NaN cond yields NaN.

// Cap 30-DTE mid IV at its own 20-day average
iv = option.iv(30, sampling=sampling(period="day", time="close"))
avg = rolling_mean(iv, 20)
where(iv > avg, avg, iv)

Like the comparison and logical operators, is_missing returns Float64 1.0 / 0.0, never a boolean column.

Lag, diff & change

Four functions that reference a prior observation. Each requires a timeseries and periods >= 1. The first periods observations are null because no history exists yet.

lag(x: Signal, periods: Int) -> Signal
diff(x: Signal, periods: Int) -> Signal
pct_change(x: Signal, periods: Int) -> Signal
log_change(x: Signal, periods: Int, base: "e" | 2 | 10 = "e") -> Signal

• lag(x, periods) shifts x forward by periods positions: result[i] = x[i - periods].
• diff(x, periods) returns x - lag(x, periods).
• pct_change(x, periods) returns x / lag(x, periods) - 1.
• log_change(x, periods, base) returns log(x / lag(x, periods), base).

pct_change and log_change divide by the lagged value, so a zero denominator yields NaN; log_change also yields NaN when the ratio is zero or negative.

Rolling aggregations

Sixteen windowed functions. Each aggregates a trailing observation-count window of x.

Shared keyword arguments. Every rolling function except rolling_count takes:

• periods (required, positional): window size in observations.
• min_periods (default null): minimum valid observations required to emit a value; null requires the full window of size periods. Below min_periods valid values, the output is null.
• ignore (default "both", also "null" / "nan"): which missing kinds to skip when forming the window.

rolling_std, rolling_var, and rolling_zscore add ddof (default 0, population; 1 for sample). rolling_winsorize adds lower_q / upper_q. rolling_ewma sets its decay through exactly one of half_life, alpha, or center_of_mass; with none supplied, periods is used as the span.

// WRONG: option.iv(30) is a 1-minute series, so 252 is 252 minutes
rolling_rank(option.iv(30), 252)

// RIGHT: sample to daily first, then 252 observations is ~1 year
iv_daily = option.iv(30, sampling=sampling(period="day", time="close"))
rolling_rank(iv_daily, 252)

Arithmetic, comparison & logical operators

Comparison and logical operators return Float64 1.0 / 0.0, not booleans. Because the result stays numeric, masks compose by multiplication (AND) and addition (OR):

// Enter only when 1-year IV rank is elevated and price is above its 20-day mean
iv_daily = option.iv(30, sampling=sampling(period="day", time="close"))
close_daily = bar.close(sampling=sampling(period="day", time="close"))
(rolling_rank(iv_daily, 252) > 0.50) && (close_daily > rolling_mean(close_daily, 20))

Division of a finite numerator by zero yields NaN. Both operands align on the union spine with backward as-of fill before the operator applies; null and NaN propagate, and NaN takes precedence over null.

Operator precedence

Highest to lowest. Use parentheses to override.

Accessors

Three accessor families pull market and calendar data onto the active spine:

• bar.*: open, high, low, close, volume.
• option.*: delta, gamma, theta, vega, rho, iv, plus contract, which returns a ContractTable (see below).
• time.*: calendar attributes and session math (day_of_week, hour, minute_of_day, trading_days, session_fraction, and the rest).

Each of these returns a Signal and accepts sampling= / bucketing= to derive a coarser frequency, with one exception: option.contract returns a ContractTable and takes no sampling= / bucketing=. Full parameter tables, target-selection arguments (dte, delta, moneyness), and per-symbol coverage live in the data accessor reference.

Backtest-context accessors

Four callables return Tables rather than Signals: book(), position(), leg(slug), and option.contract(...). Each is a registered callable in the compiler. You get a usable value by projecting one numeric column with field access, which yields a Signal you can feed to any operator.

Three of them read live engine state and are gated by the evaluation context, so they resolve only in the slots where their backing state exists:

• book(): whole-account state. Available in entry signals, exit signals, and adjustment triggers.
• position(): the structure under evaluation, aggregated across its legs. Available in adjustment triggers only.
• leg(slug): one leg of the position, addressed by its strategy slug. Available in adjustment triggers, where it reads the live held leg, and in a leg's contract selection, where it resolves the referenced leg's run-start candidate.

option.contract(...) is the contract-selection accessor: the per-minute selected contract, returned as a ContractTable. It reads market data and is not context-gated the way the three state accessors are.

Using a state accessor outside its slot raises an availability error that names the accessor and the context.

// Adjustment trigger: roll when the short put's delta breaches 0.40
leg("short_put").delta > 0.40

// Margin defense: fire when account excess liquidity drops below $5,000
book().excess_liquidity < 5000

Column inventories and per-context availability live in the data accessor reference; for how these slot into a strategy, see signals inside a backtest.

Known naming pitfalls