Enum Expr 

pub enum Expr {
    Literal(Value),
    Call {
        op: String,
        args: Vec<Expr>,
    },
    Let {
        bindings: Vec<(String, Expr)>,
        body: Box<Expr>,
    },
    Var(String),
    Match {
        input: Box<Expr>,
        arms: Vec<(Vec<Value>, Expr)>,
        default: Box<Expr>,
    },
    Step {
        input: Box<Expr>,
        output0: Box<Expr>,
        stops: Vec<(f64, Expr)>,
    },
    Interpolate {
        kind: InterpKind,
        space: InterpSpace,
        input: Box<Expr>,
        stops: Vec<(f64, Expr)>,
        projection: bool,
    },
    Format(Vec<FormatArg>),
    Within(Vec<Vec<Vec<(f64, f64)>>>),
    Distance(Vec<SimpleGeom>),
    Collator {
        case_sensitive: Option<Box<Expr>>,
        diacritic_sensitive: Option<Box<Expr>>,
        locale: Option<Box<Expr>>,
    },
    NumberFormat {
        value: Box<Expr>,
        locale: Option<Box<Expr>>,
        currency: Option<Box<Expr>>,
        min_fraction_digits: Option<Box<Expr>>,
        max_fraction_digits: Option<Box<Expr>>,
        unit: Option<Box<Expr>>,
    },
    Assert(Type, Box<Expr>),
    Coerce(Type, Box<Expr>),
}

A parsed MapLibre expression.

Most operators are represented uniformly as Expr::Call; the handful of operators with irregular argument shapes (bindings, unquoted match labels, stop lists) get dedicated variants so evaluation stays simple.

Variants

Literal(Value)

A constant value (bare literal or the literal operator).

Call

A generic operator call whose arguments are all sub-expressions.

Fields

op: String

args: Vec<Expr>

Let

["let", name, value, ..., body]

Fields

bindings: Vec<(String, Expr)>

body: Box<Expr>

Var(String)

["var", name]

Match

["match", input, label, output, ..., default]

Fields

input: Box<Expr>

arms: Vec<(Vec<Value>, Expr)>

default: Box<Expr>

Step

["step", input, output0, stop1, output1, ...]

Fields

input: Box<Expr>

output0: Box<Expr>

stops: Vec<(f64, Expr)>

Interpolate

["interpolate"|"interpolate-hcl"|"interpolate-lab", type, input, stop, output, ...]

Fields

kind: InterpKind

space: InterpSpace

input: Box<Expr>

stops: Vec<(f64, Expr)>

projection: bool

Set when the output type is projectionDefinition, which is interpolated specially (stop outputs stay raw).

Format(Vec<FormatArg>)

["format", content, options?, ...] — styled text sections.

Within(Vec<Vec<Vec<(f64, f64)>>>)

["within", geojson] — the argument polygons as [lng, lat] rings (a multipolygon: list of polygons, each a list of rings).

Distance(Vec<SimpleGeom>)

["distance", geojson] — the argument geometries in [lng, lat].

Collator

["collator", options] — a locale-aware string collator.

Fields

case_sensitive: Option<Box<Expr>>

diacritic_sensitive: Option<Box<Expr>>

locale: Option<Box<Expr>>

NumberFormat

["number-format", value, options].

Fields

value: Box<Expr>

locale: Option<Box<Expr>>

currency: Option<Box<Expr>>

min_fraction_digits: Option<Box<Expr>>

max_fraction_digits: Option<Box<Expr>>

unit: Option<Box<Expr>>

Assert(Type, Box<Expr>)

A runtime type assertion inserted by type checking: the inner expression must already produce the given type at runtime, or evaluation errors.

Coerce(Type, Box<Expr>)

A runtime coercion inserted by type checking: the inner expression’s value is converted to the given type (e.g. string → color).

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.