Expressions¶

This page covers all expression forms in Graphcal: operators, precedence, and conditionals.

Operator Precedence¶

From lowest to highest precedence:

Parentheses () can be used to override precedence. -> binds at the lowest level, so the trailing form expr -> unit wraps everything to its left.

Arithmetic Operators¶

Comparison Operators¶

All comparison operators return Bool.

Logical Operators¶

Operands must be Bool.

&& and || always evaluate both operands (no short-circuit). In a reactive calculation graph every sub-expression should be valid regardless of control flow, so Graphcal surfaces errors eagerly rather than hiding them behind a short-circuit. Use if-then-else when you need conditional evaluation.

Unit Conversion (->)¶

Convert a value to a different unit of the same dimension:

node alt_m: Length = @altitude -> m;
node time_h: Time = @duration -> hour;

Phantom Type Change (Explicit Reconstruction)¶

There is no phantom-type cast operator. To change a phantom type parameter, construct a new instance and assign each field explicitly:

node pos_body: Vec3<Length, Body> = Vec3<Length, Body>(
    x: @pos_eci.x,
    y: @pos_eci.y,
    z: @pos_eci.z,
);

The verbosity is intentional: re-labeling (e.g., changing a reference frame) is a deliberate, field-by-field act, not a silent reinterpretation.

Field Access (.)¶

Access a field of a struct-typed value:

node dv: Velocity = @transfer.total_dv;

Index Access ([...])¶

Access an element of an indexed value:

node first: Velocity = @delta_v[Maneuver.Departure];

If/Else Expressions¶

Conditional expressions:

node clamped: Int = if @a > @seven { @seven } else { @a };

Both branches must have the same type and dimension. The else branch is required.

Inline DAG Invocation (@dag(args).out)¶

A dag can be invoked as an expression, producing a fresh sub-graph at every syntactic call site:

node doubled: Length = @scale(factor: 2.0, v: @src).result;

The projected output after . is mandatory. Arguments are evaluated in the surrounding scope, so they may reference loop variables from an enclosing for comprehension or other local binders.

The thing immediately after @ may be a DAG in scope or a module-qualified DAG path such as @module.dag(args).out. The projected output after the call is what makes the expression a graph reference.

See Multi-File: Inline-DAG Call Expression for the full semantics.

Numeric Literals¶