Enum jrsonnet_parser::Expr

pub enum Expr {
    Literal(LiteralType),
    Str(IStr),
    Num(f64),
    Var(IStr),
    Arr(Vec<LocExpr>),
    ArrComp(LocExpr, Vec<CompSpec>),
    Obj(ObjBody),
    ObjExtend(LocExpr, ObjBody),
    Parened(LocExpr),
    UnaryOp(UnaryOpType, LocExpr),
    BinaryOp(LocExpr, BinaryOpType, LocExpr),
    AssertExpr(AssertStmt, LocExpr),
    LocalExpr(Vec<BindSpec>, LocExpr),
    Import(LocExpr),
    ImportStr(LocExpr),
    ImportBin(LocExpr),
    ErrorStmt(LocExpr),
    Apply(LocExpr, ArgsDesc, bool),
    Index(LocExpr, LocExpr),
    Function(ParamsDesc, LocExpr),
    IfElse {
        cond: IfSpecData,
        cond_then: LocExpr,
        cond_else: Option<LocExpr>,
    },
    Slice(LocExpr, SliceDesc),
}

Syntax base

Variants

Literal(LiteralType)

Str(IStr)

String value: “hello”

Num(f64)

Number: 1, 2.0, 2e+20

Var(IStr)

Variable name: test

Arr(Vec<LocExpr>)

Array of expressions: [1, 2, “Hello”]

ArrComp(LocExpr, Vec<CompSpec>)

Array comprehension:

 ingredients: [
   { kind: kind, qty: 4 / 3 }
   for kind in [
     'Honey Syrup',
     'Lemon Juice',
     'Farmers Gin',
   ]
 ],

Obj(ObjBody)

Object: {a: 2}

ObjExtend(LocExpr, ObjBody)

Object extension: var1 {b: 2}

Parened(LocExpr)

(obj)

UnaryOp(UnaryOpType, LocExpr)

-2

BinaryOp(LocExpr, BinaryOpType, LocExpr)

2 - 2

AssertExpr(AssertStmt, LocExpr)

assert 2 == 2 : “Math is broken”

LocalExpr(Vec<BindSpec>, LocExpr)

local a = 2; { b: a }

Import(LocExpr)

import “hello”

ImportStr(LocExpr)

importStr “file.txt”

ImportBin(LocExpr)

importBin “file.txt”

ErrorStmt(LocExpr)

error “I’m broken”

Apply(LocExpr, ArgsDesc, bool)

a(b, c)

Index(LocExpr, LocExpr)

a[b]

Function(ParamsDesc, LocExpr)

function(x) x

IfElse

Fields

cond: IfSpecData

cond_then: LocExpr

cond_else: Option<LocExpr>

if true == false then 1 else 2

Slice(LocExpr, SliceDesc)

Trait Implementations

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq<Expr> for Expr

fn eq(&self, other: &Expr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Trace for Expr

fn trace(&self, tracer: &mut Tracer<'_>)

Define how to visit values referred by this value.

fn is_type_tracked() -> bool

Whether this type should be tracked by the collector.

impl StructuralPartialEq for Expr