Typed program results and symbolic errors

Float math and activations

Use trigonometric, exponential, logarithmic and activation functions for numeric calculations or rotation angles. Functions in this catalogue take one Float and return Float; convert Int explicitly with int_to_float(...). Sine/cosine also accept Angle. Float angles are radians; use degrees(...) to construct an explicit Angle from degrees.

• sin(value: Float) -> Float — Sine of a Float angle in radians. Also accepts an Angle and returns a Float using its canonical radian quantity.
• cos(value: Float) -> Float — Cosine of a Float angle in radians. Also accepts an Angle and returns a Float using its canonical radian quantity.
• sqrt(value: Float) -> Float — Square root of a nonnegative Float.
• exp(value: Float) -> Float — Natural exponential of a Float; rejects results above the Float bound.
• log(value: Float) -> Float — Natural logarithm of a strictly positive Float.
• log1p(value: Float) -> Float — Natural logarithm of 1 + value, accurate near zero; requires input greater than -1.
• expm1(value: Float) -> Float — Natural exponential minus one, accurate near zero; rejects results above the Float bound.
• tanh(value: Float) -> Float — Hyperbolic tangent of a Float, in the range [-1, 1].
• sigmoid(value: Float) -> Float — Stable logistic sigmoid of a Float, in the range [0, 1].
• abs(value: Float) -> Float — Absolute value of a Float; parameter-dependent zero has no analytic derivative.
• floor(value: Float) -> Float — Rounds down to an integer-valued Float; analytic derivatives reject parameter-dependent integer inputs.
• ceil(value: Float) -> Float — Rounds up to an integer-valued Float; analytic derivatives reject parameter-dependent integer inputs.
• round(value: Float) -> Float — Nearest integer-valued Float, ties toward positive infinity; analytic derivatives reject parameter-dependent half-integers.

Vectors and numeric operations

• min(Float, Float) -> Float — Minimum
• max(Float, Float) -> Float — Maximum
• clamp(Float, Float, Float) -> Float — Clamp to inclusive bounds
• sum(Array<T, N>) -> T — Checked sum
• dot(Array<T, N>, Array<T, N>) -> T — Inner product
• norm(Array<Float, N>) -> Float — Euclidean norm
• add(Array<T, N>, Array<T, N>) -> Array<T, N> — Elementwise addition
• sub(Array<T, N>, Array<T, N>) -> Array<T, N> — Elementwise subtraction
• scale(Array<T, N>, T) -> Array<T, N> — Scalar multiplication
• variance(Array<Float, N>) -> Float — Population variance
• stddev(Array<Float, N>) -> Float — Population standard deviation
• argmin(Array<T, N>) -> Int — First minimum index
• argmax(Array<T, N>) -> Int — First maximum index

T is Int or Float; N is a fixed array length from 1–256. Two vectors must have the same element type and length; the scale multiplier must match the element type. sum/dot preserve that type. min/max/clamp take Float only; clamp requires lower ≤ upper. norm/variance/stddev take Float arrays only. variance is population variance (divided by N); stddev is its square root. argmin/argmax return a zero-based Int index, choosing the first element on ties. In the example, bend uses dot to compute the same rotation angle; magnitude shows vector length and spread shows variance.

Analytic gradients reject parameter-dependent argmin/argmax, min/max ties, norm at zero, and zero stddev for arrays with multiple elements. clamp rejects parameter-dependent boundary contacts; equal constant bounds produce a constant with zero derivative. Single-element stddev has zero derivative. Constant operations are exempt from derivative restrictions, but numeric bounds and shape checks still apply. Vector operations consume the helper execution budget in proportion to their element count.

A typed main expression needs typedClassicalValues. Helper bodies and direct gate-angle calls also need classicalFunctions. The example enables both: scale = 2, wave ≈ 0.389418, and the Z expectation is ≈ 0.952382. Imported helpers may use sin/cos/sqrt too; no standard-library import is needed.

1module float_math;2param theta: Angle = 0.4;3 4fn bend(x: Float) -> Float {5  return dot([sin(x), cos(x)], [1.0, 0.25]);6}7 8fn main() {9  let q = qreg[1];10  let scale: Float = sqrt(int_to_float(4));11  let wave: Float = sin(theta);12  let probability: Float = sigmoid(theta);13  let activation: Float = tanh(theta);14  let features: Array<Float, 2> = [wave, activation];15  let magnitude: Float = norm(features);16  let spread: Float = variance(features);17  let bounded: Float = clamp(probability, 0.0, 1.0);18  Ry(q[0], bend(theta) / scale);19  Rz(q[0], cos(theta));20  let cost = expect Z(q[0]);21  return cost;22}

sqrt(-1.0) fails at runtime; it is not silently replaced by zero or NaN. sqrt(0.0) is valid during ordinary evaluation. This version does not support analytic gradients through parameter-dependent sqrt at zero; training/gradient explicitly rejects it. Parameter-independent sqrt(0.0) remains constant. Unselected short-circuit branches are not evaluated.

log requires positive input; log1p requires input greater than -1. exp and expm1 fail when their result exceeds the 10¹² Float bound. log1p/expm1 retain precision near zero. Sigmoid and tanh avoid overflow at large inputs; floating-point rounding may produce their endpoints. The example yields probability ≈ 0.598688 and activation ≈ 0.379949.

abs, floor, ceil and round return Float. round resolves ties toward positive infinity: round(-1.5) = -1.0. Analytic gradients reject parameter-dependent abs at zero, floor/ceil at integers, and round at half-integers. Elsewhere rounding has zero derivative, so a parameter connected only through rounding receives no gradient update. Parameter-independent constants are exempt from these derivative restrictions.

Names in the unary Float catalogue are reserved; do not use them for custom helpers. In the numeric catalogue below, a same-named user function, including an imported helper, takes precedence over the builtin.

Helpers in measured branches

Use typed locals, helper calls and math gate angles in the selected main branch. With classicalFunctions and typedClassicalValues enabled, Bool values and Bool-returning helpers support nested if/else; existing measurement conditions remain available.

The example enables classicalFunctions, typedClassicalValues and functionResults. X makes the measurement 1: the result is angle ≈ 0.479426. Remove X(q[0]) to return ZERO_MEASUREMENT. Change checked_angle(0.5)? to checked_angle(-0.5)? to return NEGATIVE_ANGLE before the Ry gate. Only the selected branch runs; an early Result return stops subsequent operations.

1module measured_helpers;2 3fn checked_angle(value: Float) -> Result<Float, Error> {4  if (value < 0.0) {5    return error("NEGATIVE_ANGLE");6  }7  return ok(sin(value));8}9 10fn main() -> Result<Float, Error> {11  let q = qreg[2];12  X(q[0]);13  let measured: Bit = measure(q[0]);14  if (measured == 1) {15    let angle: Float = checked_angle(0.5)?;16    Ry(q[1], cos(angle));17    return ok(angle);18  } else {19    return error("ZERO_MEASUREMENT");20  }21}

Block locals stay inside their block. Sibling branches may reuse a name; shadowing an outer binding is rejected. Editor completion, type information, references and rename preserve these boundaries. Rename requires complete, valid source. Int/Float let mut and constant-range for loops share a 4096-step execution budget; unbounded repetition is unsupported.

Statevector supports helpers in observe/test/snapshot blocks. MPS explicitly rejects these report blocks and until; stabilizer falls back to statevector for report blocks. Projecting dynamically controlled helper calls to QASM or framework circuits is rejected with NM-CFN-011; keep the original N/M source.

Main loops, dynamic indices and Results

The example links enable classicalFunctions, typedClassicalValues and functionResults together. The source runs on statevector, MPS and stabilizer while retaining each engine's gate capabilities.

1module indexed_accumulation;2fn main() -> Result<Float, Error> {3  let q = qreg[2];4  let weights: Array<Float, 2> = [1.5, 3.0];5  let mut total: Float = 0.0;6  for i in 0..2 {7    total = total + weights[i];8    X(q[i]);9  }10  return ok(total);11}

1module main_result_recovery;2fn checked(value: Float) -> Result<Float, Error> {3  if (value < 0.0) { return error("NEGATIVE"); }4  return ok(value * 2.0);5}6fn main() -> Result<Float, Error> {7  let q = qreg[1];8  let attempt: Result<Float, Error> = checked(1.5);9  match (attempt) {10    ok(value) => {11      X(q[0]);12      return ok(value);13    }14    error => {15      return attempt;16    }17  }18}

1module mutation_gradient;2param theta:Angle=0.3;3fn main(){4 let q=qreg[1];5 let xs:Array<Float,3>=[theta,theta*theta,theta*3.0];6 let mut total:Float=0.0;7 let mut cursor:Int=2;8 for i in 0..3 {9  total=total+xs[cursor];10  cursor=cursor-1;11 }12 Ry(q[0],total);13 let cost=expect Z(q[0]);14 let slope=gradient cost wrt theta;15 return slope;16}

1module array_mutation_gradient;2param theta:Angle=0.3;3fn main(){4 let q=qreg[1];5 let mut xs:Array<Float,2>=[theta,theta*theta];6 let original:Array<Float,2>=xs;7 for i in 0..2 {8  xs[i]=xs[i]*theta;9 }10 xs[0]=xs[0]+original[0];11 Ry(q[0],xs[0]+xs[1]);12 let cost=expect Z(q[0]);13 let slope=gradient cost wrt theta;14 return slope;15}

Loop bounds are constant integers: 0 ≤ start ≤ end ≤ 256. Nested loops, expressions and helpers share a 4096-step budget. Gate targets must be Int, stay within their register and be distinct for multi-target gates. Dynamic indexing does not extend to measurement/reset targets.

Main Result payloads may be Int, Float, Bool, Bit or fixed Int/Float/Bit arrays; nested Results and Bool arrays are unsupported. Bit is not implicitly converted to Int. Numeric helpers accept Result parameters, but Bit payloads need explicit conversion. A Result error is a successful engine execution; out-of-bounds access or division by zero is a runtime failure.

N/M source and JSON IR preserve these examples. Scalar main assignments, bounded loops and parameter-independent array reads support adjoint training; parameter-independent Int qubit targets also work with bounds checks. QASM/framework export and optimization reject this dynamic flow. The static circuit view shows unresolved targets as q[?] and reports uncertain resource bounds when they cannot be determined reliably.

Store Results and recover inside helpers

Store a Result<T, Error> in a typed local inside a pure helper; handle both ok(value) and error explicitly with match (attempt). Each arm must appear exactly once, in either order. The selector must name a Result local. The ok payload has type T and stays inside its arm; the error arm does not introduce an error variable.

The example enables all three experimental features. recover(-1.0) deliberately converts NEGATIVE_ROOT into Float: 0. recover(4.0) returns Float: 2. Replace the main call with forward(-1.0)? to preserve the original NEGATIVE_ROOT code and return before Ry executes. Errors do not silently become success; the source explicitly chooses a fallback value.

1module result_recovery;2 3fn checked_root(value: Float) -> Result<Float, Error> {4  if (value < 0.0) {5    return error("NEGATIVE_ROOT");6  }7  return ok(sqrt(value));8}9 10fn recover(value: Float) -> Float {11  let attempt: Result<Float, Error> = checked_root(value);12  match (attempt) {13    ok(root) => {14      return root;15    }16    error => {17      return 0.0;18    }19  }20}21 22fn forward(value: Float) -> Result<Float, Error> {23  let attempt: Result<Float, Error> = checked_root(value);24  match (attempt) {25    ok(root) => {26      return ok(root);27    }28    error => {29      return attempt;30    }31  }32}33 34fn main() -> Result<Float, Error> {35  let q = qreg[1];36  let value: Float = recover(-1.0);37  Ry(q[0], value);38  return ok(value);39}

Result locals and exhaustive two-arm matches work in helpers and main with all three experimental flags. Helpers also accept Result parameters. Nested Results remain unsupported. T may be Int, Float, Bool or a fixed Int/Float array. Local attempt? unwraps success or forwards the original error in a Result-returning helper or main, for example return ok(attempt?);. The error arm may return attempt; to preserve its original code. The ok binding counts toward the 32-local limit. Analytic gradients of helpers in this native Error Result example are unsupported. Typed-error recovery derivatives have a separate supported contract.

The editor shows Result-local and ok-payload types. Completion, definitions, references and rename preserve arm boundaries and leave another helper's same-named value alone. Renames that shadow an outer binding are rejected.

Carry records and enums in Results

A successful helper can return a record or enum instead of a single number. In Result<Sample,Problem>, Sample is the success type and Problem is the error enum. A match opens the record fields in its success arm or the error variant in its error arm. Module identities remain distinct across file boundaries.

checked(0.5) produces a record with energy 0.25, giving a circuit expectation of cos(0.25). Change the input to -1.0 to run only the error arm with the explicitly chosen angle 0.5. The example enables all three experimental features.

1module aggregate_result;2record Sample {energy:Float}3enum Problem {Negative}4 5fn checked(value:Float)->Result<Sample,Problem>{6 if(value<0.0){return error(Problem.Negative);}7 return ok(Sample {energy:value*value});8}9 10fn main(){11 let q=qreg[1];12 let attempt:Result<Sample,Problem>=checked(0.5);13 match(attempt){14  ok(sample)=>{Ry(q[0],sample.energy);}15  error(reason)=>{Ry(q[0],0.5);}16 }17 let cost=expect Z(q[0]);18 return cost;19}

The success record and error enum can also live in different files. The four-file example uses record and enum Results together, producing cos(0.5). Change both 0.5 inputs in the entry file to -1.0 to take the error arms and produce cos(0.75).

main can also return the record as its program result. This example returns energy: 0.25. Change the checked input to -1.0 and ? returns the error; the first X gate remains applied and the second X is skipped. Returning a typed program error is different from a simulator execution failure.

Array, Complex and matrix results

This example returns a two-element Complex matrix: complex(0.25, 0) and complex(0.5, 1). Change the checked input to -1.0 to return Negative; the first X is applied and the second X is skipped. Array length, matrix dimensions and element type remain checked on both success and error paths.

1module compound_result_lesson;2enum Problem {Negative}3fn checked(x:Float)->Result<Matrix<Complex,1,2>,Problem>{4 if(x<0.0){return error(Problem.Negative);}5 return ok(complex_matrix(1,2,[x,0.5],[0.0,1.0]));6}7fn main()->Result<Matrix<Complex,1,2>,Problem>{8 let q=qreg[1];9 X(q[0]);10 let value:Matrix<Complex,1,2>=checked(0.25)?;11 X(q[0]);12 return ok(value);13}

Record/enum and numeric array/Complex/matrix success values work in helper returns, Result parameters, main locals and main program results. In Result-returning functions with the same error enum, ? unwraps success or forwards the error. Generic record and enum types are shown in the example below. Nested Results remain unsupported. Numeric derivatives through typed-error recovery are supported; parameter-dependent discrete branch choices are rejected.

Generic records and enums carrying values

Box<T> stores different types in one record shape: Box<Sample> holds a sample and Box<Int> holds an integer. Problem<T>.Bad(T) returns a value with an error. Type arguments can be nested; each field type is checked during compilation.

In Playground, load the source and context, then select Run. attempt(false) returns a record containing energy: 0.25. The two X gates cancel, leaving the final state |0⟩.

Replace attempt(false) with attempt(true) and run again. The error carries 7 inside Box<Int>. The ? operator ends the program before the second X gate, leaving |1⟩. This is a typed program result, distinct from a simulator execution failure.

1module model;2pub record Box<T> { value: T }

1module values;2pub record Sample { energy: Float }

1module problem;2pub enum Problem<T> { Missing, Bad(T) }

1module app;2use workspace.model as m;3use workspace.values as v;4use workspace.problem as e;5 6fn attempt(failed: Bool) -> Result<m.Box<v.Sample>, e.Problem<m.Box<Int>>> {7  if (failed) {8    return error(e.Problem<m.Box<Int>>.Bad(m.Box<Int> { value: 7 }));9  }10  return ok(m.Box<v.Sample> { value: v.Sample { energy: 0.25 } });11}12 13fn main() -> Result<m.Box<v.Sample>, e.Problem<m.Box<Int>>> {14  let q = qreg[1];15  X(q[0]);16  let sample: m.Box<v.Sample> = attempt(false)?;17  X(q[0]);18  return ok(sample);19}

Navigate to uses of Box, rename the record’s value field or inspect the payload type inside a .Bad( call. Enum variables opened by match are visible only in their own arm. Cross-file rename validates the affected code.

m, v and e are file aliases. Aliases preserve type identity; a Sample with identical fields in another module is a different type. Only pub declarations are available to other files.

Experimental. Supports up to 4 type parameters per declaration, 8 payload items per enum variant and 256 concrete nominal types per compilation. Recursive types and nested Results are unsupported. Numeric derivatives through nested records, enum payloads and typed-error recovery are supported; parameter-dependent discrete decisions are rejected. Main scalar/array mutation derivatives follow the main runtime contract on this page.

From nested values to gate angles and derivatives

The angle passes through Box → Choice.Some → Box. Load source and context, then run: slope describes how the Z expectation changes with theta. The expected derivative is −sin(0.29/1.04) × 0.6/1.04. match opens only the selected payload and preserves its numeric derivative.

1module nested_gradient;2param theta:Angle=0.3;3param phi:Angle=0.2;4record Box<T>{value:T}5enum Choice<T>{None,Some(T)}6fn make(x:Float,y:Float)->Box<Choice<Box<Float>>> {7  return Box<Choice<Box<Float>>>{value:Choice<Box<Float>>.Some(Box<Float>{value:(x*x+y)/(y*y+1.0)})};8}9fn angle(item:Box<Choice<Box<Float>>>)->Float {10  return match(item.value){Choice<Box<Float>>.None=>0.0,Choice<Box<Float>>.Some(sample)=>sample.value};11}12fn main(){13  let q=qreg[1];14  let item:Box<Choice<Box<Float>>>=make(theta,phi);15  Ry(q[0],angle(item));16  let cost=expect Z(q[0]);17  let slope=gradient cost wrt theta;18  return slope;19}

Recovery and derivatives from error payloads

checked carries theta² inside an error. Propagation skips the remaining calculation; recover doubles the payload. The gate angle is 2 × theta². Run the example to obtain slope ≈ −0.214835488111. Error-branch selection is independent of the parameter; the number inside the error retains its derivative.

1module recovery_gradient;2param theta:Angle=0.3;3record Box<T>{value:T}4enum Problem<T>{Bad(T),Empty}5fn checked(x:Float)->Result<Box<Float>,Problem<Box<Float>>>{6 return error(Problem<Box<Float>>.Bad(Box<Float>{value:x*x}));7}8fn forwarded(x:Float)->Result<Float,Problem<Box<Float>>>{9 let item:Box<Float>=checked(x)?;10 return ok(item.value*3.0);11}12fn recover(result:Result<Float,Problem<Box<Float>>>)->Float{13 match(result){14  ok(value)=>{return value;}15  error(reason)=>{return match(reason){Problem<Box<Float>>.Bad(item)=>item.value*2.0,Problem<Box<Float>>.Empty=>0.0};}16 }17}18fn main(){19 let q=qreg[1];20 let result:Result<Float,Problem<Box<Float>>>=forwarded(theta);21 Ry(q[0],recover(result));22 let cost=expect Z(q[0]);23 let slope=gradient cost wrt theta;24 return slope;25}

Bounded helper loops and mutable numeric locals

Inside a pure helper, explicitly declare let mut Int or Float locals and assign values of the same type. for i in 0..4 runs with i = 0, 1, 2, 3; the end is exclusive. Bounds must be literal integers from 0 through 256. Equal bounds mean zero iterations; reversed ranges are rejected.

The example sums four Floats: [0.1, 0.2, 0.3, 0.4] → Float: 1. Change 0..4 to 0..0 for a zero total. Change it to 0..5 and values[4] raises a bounds error rather than reading a silent value. The example enables classicalFunctions and typedClassicalValues, plus functionResults for main's Result return.

1module bounded_sum;2 3fn sum_values(values: Array<Float, 4>) -> Float {4  let mut sum: Float = 0.0;5  for i in 0..4 {6    sum = sum + values[i];7  }8  return sum;9}10 11fn main() -> Result<Float, Error> {12  let q = qreg[1];13  let values: Array<Float, 4> = [0.1, 0.2, 0.3, 0.4];14  let total: Float = sum_values(values);15  Ry(q[0], total);16  return ok(total);17}

The inferred Int loop index is immutable and visible only in its body. Parameters, ordinary let locals, ok payloads and arrays remain immutable. Only let mut Int/Float locals may be reassigned; there is no implicit Int/Float coercion. Loop locals are recreated per iteration, cannot escape their block or shadow outer names. A fallback return is required after the loop; a return only inside the loop is insufficient. Nested loops and helper calls share the 4096 evaluation-step budget; no while syntax is added.

Helper array indices may be any Int expression: a parameter, local, loop index or calculation. Negative or out-of-range indices fail at runtime. Main also supports runtime Int indices with classicalFunctions and typedClassicalValues; see the main runtime examples on this page. Analytic training supports literal-bound helper loops in 0–256, Int/Float accumulation and bounds-checked Int indices independent of the differentiated input. Nested calls and loops share the 4096-step budget. Parameter-dependent discrete decisions/indices and runtime-dependent loop bounds are rejected. Typed Result recovery and bounded main-loop derivatives follow their separate contracts.

The editor marks mut locals as mutable and loop indices as readonly. References and rename follow both reads and assignment targets while leaving a sibling loop's same-named index unchanged.

Separate same-named helpers with module aliases

use workspace.scale as linear; exposes helpers only through linear.adjust(...). Two modules may export the same adjust name; an aliased import does not introduce a flat adjust(...) name. Here linear.adjust(0.25) and shifted.adjust(0.25) each return 0.5 from their own module, producing Float: 1.

The transfer carries the entry source and both scale and offset modules. Explicitly load source and context in Playground; the classicalFunctions, typedClassicalValues, functionResults and moduleVisibility features are shown before loading. Run it yourself afterward. Transfer never starts execution automatically.

1module alias_demo;2use workspace.scale as linear;3use workspace.offset as shifted;4 5fn main() -> Result<Float, Error> {6  let q = qreg[1];7  let first: Float = linear.adjust(0.25);8  let second: Float = shifted.adjust(0.25);9  let angle: Float = first + second;10  Ry(q[0], angle);11  return ok(angle);12}

1module scale;2pub fn adjust(value: Float) -> Float {3  return value * 2.0;4}

1module offset;2private fn offset_value(value: Float) -> Float {3  return value + 0.25;4}5pub fn adjust(value: Float) -> Float {6  return offset_value(value);7}

An alias belongs only to its importing module. Private helpers and transitive dependencies remain hidden; shifted.offset_value(...) is rejected. Aliases cannot shadow another helper, parameter or local binding. This syntax imports pure helpers; it does not add general module objects or re-exports.

Completion after linear. lists only accessible members. F12 on a member opens its original helper declaration; F12 on the alias opens the import declaration. Renaming a member updates the original helper and its consumers; renaming an alias updates only that module's import and qualifiers. Source-mapped debugging preserves original module lines.

Use records and typed errors across files

One file defines the Sample record and Problem error enum; the entry program uses them through alias a. Aliases preserve type identity. The first X runs, then the negative input makes ? return an error from main before the second X.

1module workspace_import_example;2use workspace.imported_types as a;3@target("browser-statevector");4fn main()->Result<Float,a.Problem>{5 let q=qreg[1];6 let sample:a.Sample=a.make(0.5);7 let angle:Float=a.read(sample);8 if(angle>0.0){X(q[0]);}9 let input:Result<Float,a.Problem>=a.checked(-1.0);10 let value:Float=input?;11 X(q[0]);12 return ok(value);13}

1module imported_types;2pub record Sample {energy:Float}3pub enum Problem {Negative}4private fn square(x:Float)->Float{return x*x;}5pub fn make(x:Float)->Sample{return Sample{energy:square(x)};}6pub fn read(sample:Sample)->Float{return sample.energy;}7pub fn checked(value:Float)->Result<Float,Problem>{8 if(value<0.0){return error(Problem.Negative);}9 return ok(value);10}

After running, open Workspace files and replace the library's return error(Problem.Negative); with return ok(0.4);, then run again. The second X now runs too and the program returns Float: 0.4.

Experimental. Load source and context before running. Private members remain hidden. Result helper returns, main locals and main program results accept scalar, record, enum, fixed-size numeric array, Complex or matrix successes. Generic records/enums also work across files. Cross-file completion, definitions and validated rename are supported.

Develop the loss function in a separate file

losses.nm stores the prediction–label residual in a record and squares it. The entry program trains with a.loss for two updates. Results match builtin MSE on the same circuit; this is a simulator exercise.

Load source and context, then choose Run. Inspect a.loss, training history and validation/test losses. Edit losses.nm under Workspace files and run again to use the changed library.

1module learner;2use workspace.losses as a;3@dataset("moons_2d",split:"train");4param theta:Angle=0.37;5fn main(){6 let q=qreg[2];7 encode(sample_row(0),q,method:"angle");8 Ry(q[0],theta);9 let cost=expect Z(q[0]);10 train {11 objective:minimize cost;12 optimizer:gd(lr=0.1);13 steps:2;14 dataset:moons_2d;15 loss:custom(a.loss);16 validation: split = validation, every = 1;17 checkpoint: best(metric = validation_loss);18 }19 return cost;20}

1module losses;2pub record Residual {delta:Float}3enum State {Ready,Failed}4private fn squared(item:Residual)->Float{return item.delta*item.delta;}5pub fn loss(p:Float,y:Float)->Float {6 let item:Residual=Residual {delta:p-y};7 return match(State.Ready){State.Ready=>squared(item),State.Failed=>1.0/0.0};8}