expr

const (
	AggSum AggOp = iota
	AggMean
	AggMin
	AggMax
	AggCount   // non-null values
	AggLen     // rows, including nulls
	AggNUnique // distinct non-null values
	AggFirst
	AggLast

	// APPEND ONLY below this line. IsCounting and the classifiers are written
	// against declaration order, and an op inserted mid-enum silently changes its
	// neighbours' family — the same rule CallFn and UnaryOp document.
	AggNullCount // nulls, the complement of Count
	AggAny       // Boolean OR over non-null values
	AggAllTrue   // Boolean AND over non-null values
	AggVar
	AggStd
	AggProduct
	AggArgMin // index of the minimum WITHIN the group
	AggArgMax
	AggMedian
	AggQuantile
	AggImplode // every value of the group, as a List
	AggTopK    // the k largest values of the group, largest first, as a List
	AggBottomK // the k smallest values of the group, smallest first, as a List

	// Two inputs (step 175), carried as a two-field Struct, PairOf's: the value and
	// what orders it, or the two variables.
	AggCorr  // Pearson's correlation of the pairs where both are non-null
	AggCov   // their covariance, with Params.DDof
	AggMinBy // the value at the row whose second field is the least
	AggMaxBy // and the greatest

	// Step 276: the third and fourth standardized moments, with Params.Bias and
	// Params.Fisher; and the bitwise reductions of integers or Booleans.
	AggSkew
	AggKurtosis
	AggBitAnd
	AggBitOr
	AggBitXor
	AggNanMin // the minimum, NaN where there is one: Polars' nan_min

	// Step 277: entropy, with Params.Base and Params.Normalize; and Spearman's
	// correlation of a pair, PairOf's, as AggCorr.
	AggEntropy
	AggSpearman
	// Step 324: item, the group's one value, with Params.AllowEmpty; lower_bound and
	// upper_bound, its type's least and greatest; and is_sorted, with
	// Params.Descending and Params.NullsLast.
	AggItem
	AggLowerBound
	AggUpperBound
	AggIsSorted
	// Step 330: top_k_by and bottom_k_by, a pair, PairOf's, as AggMaxBy, with Params.K.
	AggTopKBy
	AggBottomKBy
	// Step 340: mode, the group's most frequent values, a List, with
	// Params.MaintainOrder: Polars' mode in an aggregation, where it was the list
	// kernel over the values imploded.
	AggMode
)

const (
	// Arithmetic.
	OpAdd BinaryOp = iota
	OpSub
	OpMul
	OpDiv      // true division: always produces a float
	OpFloorDiv // floored division: −7 // 2 is −4
	OpMod

	// Ordering and equality. Three-valued: if either operand is null the result
	// is null, NOT false.
	OpEq
	OpNe
	OpLt
	OpLe
	OpGt
	OpGe

	// Equality where nulls are DATA rather than absence: null == null is true and
	// the result is never null. Polars calls these eq_missing / ne_missing. They
	// need a separate kernel family, not a flag on the ordinary comparison.
	OpEqMissing
	OpNeMissing

	// Kleene three-valued logic. Note false AND null == false and true OR null ==
	// true — the output validity is NOT simply `va AND vb`.
	OpAnd
	OpOr
	OpXor

	// Exponentiation. APPENDED rather than placed beside the other arithmetic,
	// which reads oddly and is deliberate: both dispatchers — ResolveBinary and
	// kernel's arithmetic — route anything the classifiers below do not claim to
	// the arithmetic path through a `default:` arm, so position carries no meaning
	// for it, and renumbering the enum to make it look tidy would move every
	// constant for no gain.
	OpPow

	// Polars' arctan2(y, x), y the left (step 324): the angle of (x, y), a float, as
	// OpPow's binding casts both sides to one.
	OpArctan2
)

const (
	// --- string ---
	FnStrContains CallFn = iota
	FnStrStartsWith
	FnStrEndsWith
	FnStrFind
	FnStrCountMatches
	FnStrExtract
	FnStrReplace
	FnStrReplaceAll
	FnStrToLower
	FnStrToUpper
	FnStrLenBytes
	FnStrLenChars
	FnStrSlice
	FnStrStripChars
	FnStrStripPrefix
	FnStrStripSuffix
	FnStrReverse
	FnStrPadStart
	FnStrPadEnd
	FnStrZFill
	FnStrStripCharsStart
	FnStrStripCharsEnd
	FnStrEscapeRegex
	FnStrSplit
	FnStrSplitN
	FnStrExtractAll
	// The three parse a string with a strftime-style format (step 113): args are
	// the format, strict, and for a Datetime the unit and zone, for a Time the
	// unit. One function per target, because a type is not a literal.
	FnStrToDateFmt
	FnStrToDatetimeFmt
	FnStrToTimeFmt

	// --- temporal ---
	FnDtYear CallFn = iota + 100
	FnDtMonth
	FnDtDay
	FnDtHour
	FnDtMinute
	FnDtSecond
	FnDtMillisecond
	FnDtMicrosecond
	FnDtNanosecond
	FnDtWeekday
	FnDtOrdinalDay
	FnDtQuarter
	FnDtWeek
	FnDtEpoch
	FnDtTruncate
	FnDtTotalDays
	FnDtTotalHours
	FnDtTotalMinutes
	FnDtTotalSeconds
	FnDtStrftime // formats with a strftime-style format; the one arg is the format
	// The calendar (step 145). offset_by's args are an interval's months, days and
	// nanos; round's are truncate's; convert_time_zone's one arg is the zone.
	FnDtOffsetBy
	FnDtRound
	FnDtMonthStart
	FnDtMonthEnd
	FnDtIsLeapYear
	FnDtConvertTimeZone
	// Step 174: replace_time_zone's args are the zone, "" for none, then the
	// ambiguous and non_existent policies, in Polars' words (ZonePolicies).
	FnDtReplaceTimeZone
	FnDtDaysInMonth // the month's length, read in the column's zone (step 230)
	// The local date and time of day of an instant, Polars' dt.date and dt.time
	// (step 249).
	FnDtDate
	FnDtTime

	// --- type-agnostic ---
	//
	// A third family, and the first that is not keyed to a receiver type. The two
	// above dispatch on what the receiver IS — a String, an instant — but IsIn
	// applies to anything hashable, so it needs its own classifier rather than
	// widening either of theirs.
	FnIsIn CallFn = iota + 200

	// A value map (step 226). Args[0] is the receiver, Args[1] the count k of old
	// values as an Int64 literal, then the k old values, the k new ones, and for
	// FnReplaceOr the default. ReplaceParts reads them.
	FnReplace       // a value not among old keeps itself
	FnReplaceStrict // and here is refused
	FnReplaceOr     // and here, a null too, is the default

	// --- maths ---
	//
	// A fourth family, for the maths operations that carry a PARAMETER. The
	// parameterless ones are UnaryOps; Round needs a decimal count, and a Call is
	// where a parameter belongs.
	//
	// Not a field on expr.Unary, which was the obvious alternative: three places
	// rebuild a Unary by hand — physical/agg.go's extractAggs and both predicate
	// pushdown walkers — as `&Unary{Op: t.Op, Child: ...}`, so a new field would be
	// silently DROPPED the moment a predicate moved, and Round(2) would quietly
	// become Round(0). That is step 7's Agg.Params bug, three sites over. Call.String()
	// renders its arguments structurally, so the same class is impossible here.
	FnMathRound CallFn = iota + 300
	// FnMathAsFloat takes a number, or a Duration's ticks, to a float without
	// changing its value: an integer or a Decimal to the nearest Float64, a float as
	// itself. It is how PctChange subtracts in float, and is not public.
	FnMathAsFloat
	// FnMathDiffWiden takes an unsigned integer to the signed type that holds the
	// difference of any two of its values, and leaves every other type as it is. It
	// is how Diff subtracts without wrapping, and is not public.
	FnMathDiffWiden
	// The bit counts of an integer (step 146), Polars' bitwise_count_ones and its
	// five siblings, each a Uint32.
	FnMathCountOnes
	FnMathCountZeros
	FnMathLeadingOnes
	FnMathLeadingZeros
	FnMathTrailingOnes
	FnMathTrailingZeros

	// --- list ---
	//
	// A fifth family, keyed to a List receiver. These all reduce a list to a
	// SCALAR: nothing here builds a list, which is the seam the step was cut on —
	// sort, unique, reverse, slice and the set operations construct a new List
	// column and are a different problem.
	FnListLen CallFn = iota + 400
	FnListGet
	FnListContains
	FnListMin
	FnListMax
	FnListSum
	FnListMean
	FnListJoin // the elements of a List of String, joined; the one arg is the separator

	// list -> LIST. These reshape the list and hand back a list, which is the
	// distinction that split the namespace across two steps: everything above
	// answers a question ABOUT a list, everything here returns one.
	FnListReverse
	FnListHead
	FnListTail
	FnListSlice
	FnListSort
	FnListUnique
	FnListDropNulls

	// list -> a SCALAR again, each a column aggregate over a list's elements (step
	// 222), after the reshaping half because that is where the family ends.
	FnListNUnique
	FnListArgMin
	FnListArgMax

	// list -> STRUCT (step 224): element i as field i, its names the arguments.
	FnListToStruct
)

const (
	FnStructField        CallFn = iota + 500
	FnStructRenameFields        // every field renamed, in order (step 224)
	FnStructJSONEncode          // each struct as a JSON object (step 231)
	FnStructSelectFields        // the named fields, in that order, the struct's validity kept (step 299)
	FnStructDropFields          // the fields not named, Polars' struct.drop (step 323)

)

const (
	FnConcatStr CallFn = iota + 600
	FnStructOf
	FnCut
	FnCutLeftClosed
	FnStructWithFields

	// The list set operations and gather (step 223): their second List is an
	// operand, a column, not a parameter, so they take this family's shape. The
	// answer is named after the first.
	FnListSetUnion
	FnListSetIntersection
	FnListSetDifference
	FnListSetSymmetricDifference
	FnListGather       // an index out of range is refused
	FnListGatherOrNull // and here gives null

	// The horizontal reductions (step 225): one value a row from every operand,
	// max, min, sum and mean each the column aggregate over the row's values, and
	// any and all Kleene's.
	FnMaxHorizontal
	FnMinHorizontal
	FnSumHorizontal
	FnMeanHorizontal
	FnAnyHorizontal
	FnAllHorizontal

	// A Date's or Datetime's day with a Time of day (step 230): its second operand
	// is a column, so it takes this family's shape.
	FnDtCombine

	// A list sorted by another of its length, element for element (step 253),
	// ascending or descending, nulls first: its second list is an operand.
	FnListSortBy
	FnListSortByDesc

	// Membership and indexing whose argument is a column (step 254): is_in against
	// each row's own list, and list.get and list.contains with a per-row index and
	// value. The constant forms are their families' own; these take this one's
	// shape, every operand a column.
	FnIsInExpr
	FnListGetExpr
	FnListContainsExpr

	// String functions whose pattern is a column, and replace's whose value is (step
	// 255). Each takes the constant form's arguments after the receiver, any of the
	// pattern or value a column; the flags stay literals.
	FnStrContainsExpr   // the receiver, the pattern, literal
	FnStrStartsWithExpr // the receiver, the prefix
	FnStrEndsWithExpr
	FnStrStripPrefixExpr
	FnStrStripSuffixExpr
	FnStrSplitExpr
	FnStrReplaceExpr // the receiver, the pattern (a literal), the value, literal
	FnStrReplaceAllExpr

	// dt.offset_by with an offset a row, a duration string as Every reads it (step
	// 256).
	FnDtOffsetByExpr

	// Generators, a list a row (step 263): int_ranges(start, end, step),
	// linear_spaces(start, end, n, closed) with closed a literal Closed, and
	// value.repeat_by(n). The scalar forms are these over one row, exploded.
	FnIntRanges
	FnLinearSpaces
	FnRepeatBy

	// Temporal ranges, a list a row (step 264): start, end, the interval's months,
	// days and nanoseconds, and closed, the last four literals.
	FnDateRanges
	FnDatetimeRanges
	FnTimeRanges

	// Values from their components (step 265): date(y, m, d), datetime(y, m, d, h,
	// mi, s, us), time(h, mi, s, us); a duration's and an epoch count's ticks, Int64,
	// which the root package casts; and business_day_count(start, end, mask,
	// holidays), the mask an Int64 literal and the holidays a List(Int64) literal of
	// days.
	FnMakeDate
	FnMakeDatetime
	FnMakeTime
	FnDurationTicks
	FnEpochTicks
	FnBusinessDayCount

	// concat_list(exprs...): each row's operands in one list, a List operand's
	// elements and another's value (step 266).
	FnConcatList

	// list.shift(n) and list.count_matches(v), n and v a value a row (step 269).
	FnListShift
	FnListCountMatches

	// to_integer in a base a row, signed or unsigned, strict a literal; and
	// concat_str past nulls, the separator last (step 271).
	FnStrParseInt
	FnStrParseUint
	FnConcatStrIgnoreNulls

	// Step 272: is_business_day(value, mask, holidays), the calendar as
	// business_day_count's; add_business_days(value, n, mask, holidays, roll); and
	// replace(value, year, month, day, hour, minute, second, microsecond, ambiguous,
	// non_existent), a component a null literal to keep the value's own.
	FnDtIsBusinessDay
	FnDtAddBusinessDays
	FnDtReplace

	// Step 274's binary functions of a row's operands: contains, starts_with and
	// ends_with(value, pattern); get(value, index, null_on_oob); and slice(value, a,
	// b, mode), mode "slice" with a the offset and b the length, a null for the rest,
	// or "head" or "tail" with a their n and b a null.
	FnBinContains
	FnBinStartsWith
	FnBinEndsWith
	FnBinGet
	FnBinSlice

	// order_cmp(a, b): -1, 0 or 1 as a sorts before, with or after b in the total
	// order Sort uses, NaN above every number and -0 with 0 (step 279), which
	// search_sorted, index_of and the peaks are written in.
	FnOrderCmp

	// list.append(a, b, mode): each row's two lists one after the other, their
	// elements met as Append's mode says (step 282), which Append in an aggregation
	// lowers to.
	FnListAppend

	// hash_rows(operands..., seed): each row's hash over its operands, the row's
	// group-by key hashed as hash hashes one value's, the seed an Int64 literal last
	// (step 302).
	FnHashRows

	// arr.shift(n) and arr.dot(other), n and other a value a row (step 342): an
	// Array's list.shift, the Array kept, and the sum of two Arrays' products.
	FnArrShift
	FnArrDot
	// concat_arr(exprs...): each row's operands in one Array, an Array operand's
	// elements and another's value, of one element type (step 343).
	FnConcatArr
)

const (
	FnListMedian CallFn = iota + 700
	FnListStd
	FnListVar
	FnListQuantile
	FnListDropNans
	FnListGatherEvery
	// A List of Lists flattened a level (step 259), which Explode in an aggregation
	// lowers to: an empty or null inner list one null, as explode makes it a row.
	FnListExplode
	// Each list's indices (step 267): in its elements' sorted order, descending and
	// nulls last two literal Booleans; of its true elements; of each value's first.
	FnListArgSort
	FnListArgTrue
	FnListArgUnique
	// list.any and list.all, ignore_nulls a literal Boolean; list.item, allow_empty
	// one; list.sample, n (negative for a fraction), the fraction, with_replacement,
	// shuffle and the seed (step 269).
	FnListAny
	FnListAll
	FnListItem
	FnListSample
	// list.mode, maintain_order a literal Boolean (step 277), which Mode in an
	// aggregation lowers to.
	FnListMode
	// list.unique_counts; list.value_counts, sort, normalize, the count's name and the
	// value's (step 280).
	FnListUniqueCounts
	FnListValueCounts
	FnListRle // list.rle, each list's runs, a Struct each (step 281)
	// list.hist, the bin count or -1, include_category, include_breakpoint and the
	// edges (step 286), which Hist in an aggregation lowers to.
	FnListHist
	FnListToArray // list.to_array, the width: an Array of it (step 341)
	FnListReshape // list.reshape, the shape: each list's values in Arrays of it, as a list (step 343)

)

const (
	FnStrContainsAny CallFn = iota + 800
	FnStrReplaceMany
	FnStrExtractMany
	FnStrFindMany
	FnStrExtractGroups
	FnStrSplitExact
	FnStrSplitInclusive
	FnStrToTitlecase
	FnStrNormalize
	// Step 271: encode and decode, hex or base64; json_path_match, the path;
	// json_decode, a null literal of the type it decodes to.
	FnStrEncode
	FnStrDecode
	FnStrJsonPathMatch
	FnStrJsonDecode
)

const (
	FnDtIsoYear CallFn = iota + 900
	FnDtCentury
	FnDtMillennium
	FnDtBaseUtcOffset
	FnDtDstOffset
	FnDtWithTimeUnit
	FnDtTotalMilliseconds
	FnDtTotalMicroseconds
	FnDtTotalNanoseconds
	FnDtTotalFractional
	FnDtSecondFractional
	FnDtEpochIn
	FnDtCastTimeUnit // a Datetime's or a Duration's values in another unit, Polars' cast_time_unit (step 325)

)

const (
	FnCatGetCategories CallFn = iota + 1000
	FnCatPhysical
)

const (
	FnHash CallFn = iota + 1200
	FnOrderSign
	FnToPhysical  // the values as stored, Polars' to_physical (step 324)
	FnReinterpret // an integer's bits at the other signedness; Args[1] signed

)

const (
	FnMathRoundSigFigs CallFn = iota + 1300
	FnMathTruncate
)

const (
	FnBinEncode CallFn = iota + 1100
	FnBinDecode
	FnBinSize
	FnBinReinterpret
)

const (
	FnArrToList CallFn = iota + 1400
	FnArrReverse
	FnArrSort
	FnArrToStruct
)

const (
	// ClosedDefault defers to whatever the operation's own convention is. It is the
	// zero value precisely so that leaving the field alone cannot mean the wrong
	// thing somewhere else.
	ClosedDefault Closed = iota

	// ClosedLeft is [start, end) — the only value under which a grid of windows
	// partitions its input exactly.
	ClosedLeft

	// ClosedRight is (start, end].
	ClosedRight

	// ClosedBoth is [start, end]. A row landing exactly on a shared boundary is in
	// BOTH neighbouring windows, so the windows no longer partition and a count over
	// them exceeds the row count. That is the documented meaning, not an accident.
	ClosedBoth

	// ClosedNone is (start, end). The mirror: a row on a shared boundary is in
	// neither window and is dropped from the output entirely.
	ClosedNone
)

const (
	// InterpLinear interpolates proportionally between the two neighbours. The
	// default, and the only option whose result need not be an input value.
	InterpLinear Interpolation = iota

	// InterpLower and InterpHigher take the neighbour below or above.
	InterpLower
	InterpHigher

	// InterpNearest takes the closer neighbour, rounding half away from the lower
	// one.
	InterpNearest

	// InterpMidpoint averages the two neighbours regardless of where the rank fell
	// between them.
	InterpMidpoint
)

const (
	// MapGroupsToRows returns each row's own partition value, in the original row
	// order. The default, and the only one that composes with other columns.
	MapGroupsToRows MappingStrategy = iota

	// MapExplode leaves the output in partition-sorted order instead of permuting
	// it back. Cheaper — it skips the inverse permutation — and it REORDERS the
	// frame, so it is only safe when every other column is windowed the same way.
	MapExplode

	// MapJoin aggregates each partition into a List repeated across its rows.
	// Refused, and from step 46 the refusal names the thing that does it:
	// Col("v").Implode().Over(k) IS this, under the default mapping.
	MapJoin
)

const (
	// RankOrdinal gives every row a distinct rank, ties broken by input order.
	RankOrdinal RankMethod = iota
	// RankDense gives tied rows the same rank and does not skip the next value.
	RankDense
	// RankMin and RankMax give tied rows the lowest or highest of their positions.
	RankMin
	RankMax
	// RankAverage gives tied rows the mean of their positions, so it returns a
	// float where every other method returns an integer.
	RankAverage
)

const (
	ReshapeSort         ReshapeOp = iota // Args: descending, 0 or 1
	ReshapeHead                          // Args: n
	ReshapeTail                          // Args: n
	ReshapeSlice                         // Args: offset, length
	ReshapeReverse                       // no args
	ReshapeUnique                        // no args: first-seen order, null a value
	ReshapeDropNulls                     // no args
	ReshapeGet                           // Args: index; one value, not a column
	ReshapeDropNans                      // no args (step 253)
	ReshapeGatherEvery                   // Args: n, offset (step 253)
	ReshapeSortBy                        // Args: descending, 0 or 1; By the keys (step 253)
	ReshapeGather                        // no args; By the indices (step 257)
	ReshapeExplode                       // a List's elements (step 259); Args [1]: a generator's, an empty list no row (step 263)
	ReshapeArgSort                       // Args: descending, nulls last (step 267)
	ReshapeArgTrue                       // no args: the true rows' indices (step 267)
	ReshapeArgUnique                     // no args: each value's first index (step 267)
	ReshapeArgSortBy                     // Child: struct_of the keys; Args: each key's descending and nulls last (step 267)
	ReshapeMode                          // Args: maintain_order, 0 or 1: the most frequent values (step 277)
	ReshapeUniqueCounts                  // no args: each value's count, in first-seen order (step 280)
	ReshapeValueCounts                   // Args: sort, normalize; Label: the count's name; a Struct a value (step 280)
	ReshapeRle                           // no args: a Struct of each run's length and value (step 281)
	ReshapeAppend                        // By: the values appended; Args: their meeting, AppendStrict, AppendUpcast or AppendCast (step 282)
	ReshapeSample                        // Args: n, or -1 for a fraction; the fraction's bits; with_replacement; shuffle; the seed (step 282)
	ReshapeHist                          // Args: the bin count, or -1 for edges; include_category; include_breakpoint; the edges' bits (step 286)
	ReshapeRolling                       // By: the index; Roll: the window; Child aggregated over each row's (step 337)
	ReshapeArr                           // Args: the shape, -1 first to infer it: the values in Arrays of it (step 343)
)

const (
	SetUnion      SetOp = iota // in either
	SetIntersect               // in both
	SetDifference              // in the first and not the second
	SetXor                     // in one and not the other
)

const (
	OpNeg UnaryOp = iota
	OpAbs
	OpNot // Kleene NOT: NOT null is null

	// Null predicates. These are the only operations whose result is never null,
	// because the null-ness IS the answer.
	OpIsNull
	OpIsNotNull

	// NaN predicates. Distinct from null predicates: null.is_nan() is NULL, not
	// false. Null and NaN are different things all the way down.
	OpIsNan
	OpIsNotNan
	OpIsFinite
	OpIsInfinite

	// Transcendental and rounding maths. These are the ops whose OUTPUT TYPE
	// DIFFERS FROM THEIR INPUT — Sqrt(Int64) is Float64 — which is why they cannot
	// share unaryArith, whose whole shape assumes one type throughout.
	//
	// Contiguous, because IsMath is a range test over them.
	OpSqrt
	OpCbrt
	OpExp
	OpLn
	OpLog10
	OpLog1p

	// Sign, Floor and Ceil are NOT in that block: each keeps its operand's type, so
	// they travel with Neg and Abs through unaryArith. Grouping them with the
	// transcendentals would have made sign(Int64) and floor(Int64) into Float64s —
	// and floor on an integer is the identity, so widening it would be a schema
	// change in exchange for nothing.
	OpSign
	OpFloor
	OpCeil

	// Trigonometry, appended in step 114 rather than inserted after OpLog1p, so no
	// existing constant moves. Widening like sqrt, which is why IsMath tests a
	// second range for them. Radians in, radians out; Degrees and Radians convert.
	OpSin
	OpCos
	OpTan
	OpArcSin
	OpArcCos
	OpArcTan
	OpSinh
	OpCosh
	OpTanh
	OpArcSinh
	OpArcCosh
	OpArcTanh
	OpDegrees
	OpRadians
	// OpCot, the cotangent, 1/tan (step 283), appended after the block it joins.
	OpCot
)

const (
	WinRank WinFnOp = iota
	WinCumCount
	WinCumSum
	WinCumProd
	WinCumMin
	WinCumMax
	WinShift

	// Forward and backward fill. TWO ops rather than one plus a Reverse flag, on
	// purpose: WinFn.String() renders the op name, so the direction can never
	// collide even if the parameter rendering is imperfect. With one op the
	// direction would live ONLY in WinParams.args, which is exactly the field that
	// has been the source of every collision bug so far.
	WinForwardFill
	WinBackwardFill

	// The rolling functions (step 149): each row's answer over the Params.N rows of
	// its partition up to and including it, in the window's order, or null where
	// fewer than Params.MinSamples of them hold a value.
	WinRollingSum
	WinRollingMean
	WinRollingMin
	WinRollingMax
	WinRollingVar
	WinRollingStd
	// A median and a quantile of the window's values (step 227): Params.Q and
	// Params.Interp, a median's 0.5 and linear.
	WinRollingMedian
	WinRollingQuantile

	// The exponentially weighted functions (step 153), Polars' and pandas' ewm_*:
	// each row's answer over every row of its partition up to it, weighted by
	// Params.Alpha's decay.
	WinEwmMean
	WinEwmStd
	WinEwmVar

	// WinInterpolate fills each run of nulls between two values on the straight line
	// between them, by position in the window's order.
	WinInterpolate

	// WinRleID numbers each row's run of equal values, from 0, by the group-by's keys
	// (step 281): Polars' rle_id.
	WinRleID

	// More rolling functions (step 284), appended so no op moves: the skew and
	// kurtosis of each row's window, Params.Bias and Params.Fisher as Polars' bias and
	// fisher; each row's rank among its window's values, by Params.Method; and the
	// covariance and correlation of a pair, the child PairOf(a, b), Params.Ddof the
	// covariance's. IsRolling takes both blocks.
	WinRollingSkew
	WinRollingKurtosis
	WinRollingRank
	WinRollingCov
	WinRollingCorr

	// WinEwmSum is Polars' ewm_sum (step 285): each value plus the running sum
	// decayed by Params.Alpha, appended so no op moves; IsEwm takes it. With
	// Params.By it and WinEwmMean are ewm_sum_by and ewm_mean_by, their child
	// PairOf(value, by), decayed by Params.Period, a half-life, in by's order.
	WinEwmSum

	// WinCumulativeEval is Polars' cumulative_eval (step 286): Params.Body, lowered by
	// LowerCumulativeEval, over each row's prefix of its partition. The physical
	// window evaluates it, as no kernel can evaluate an expression.
	WinCumulativeEval

	// WinRollingMap is Polars' rolling_map (step 338): Params.Map's Go function over
	// each row's window of Params.N rows, as the rolling functions' are, appended so
	// no op moves; IsRolling takes it.
	WinRollingMap

	// WinCatCodes is each row's value's code (step 351): the order, from 0, its
	// value first appears in among the window's non-null values, by the group-by's
	// keys; a null's null. Over the frame it is a Categorical's codes, as Polars
	// numbers them in a fresh process, which the root writes ToPhysical out as.
	WinCatCodes
)