Enum SNode 

pub enum SNode {
    Num {
        value: String,
        ty: Option<Type>,
        negative: bool,
        unit: bool,
    },
    Bool {
        value: bool,
    },
    Str {
        value: String,
    },
    Unit,
    Name {
        path: Vec<String>,
    },
    DotCtor {
        name: String,
    },
    App {
        func: Box<SExpr>,
        args: Vec<SExpr>,
    },
    Field {
        object: Box<SExpr>,
        field: String,
    },
    Unary {
        op: UnaryOp,
        arg: Box<SExpr>,
    },
    Binary {
        op: BinaryOp,
        left: Box<SExpr>,
        right: Box<SExpr>,
        rounding: Option<Rounding>,
    },
    If {
        cond: Box<SExpr>,
        then: Box<SExpr>,
        otherwise: Box<SExpr>,
    },
    Let {
        name: String,
        ty: Option<Type>,
        value: Box<SExpr>,
        body: Box<SExpr>,
    },
    Match {
        scrutinees: Vec<SExpr>,
        rows: Vec<SRow>,
    },
    Match1 {
        scrutinee: Box<SExpr>,
        cases: Vec<SCase>,
    },
    ToString {
        arg: Box<SExpr>,
    },
    Show {
        arg: Box<SExpr>,
        style: ShowStyle,
    },
    Cast {
        arg: Box<SExpr>,
        to: Type,
        from: Option<Type>,
        flavor: Flavor,
    },
    Abort {
        message: String,
    },
    Print {
        expr: Box<SExpr>,
        style: ShowStyle,
        body: Box<SExpr>,
    },
    CtorObject {
        tag: String,
        fields: Vec<(String, SExpr)>,
    },
    Array {
        items: Vec<SArrayItem>,
        element: Option<Type>,
    },
    Index {
        object: Box<SExpr>,
        index: Box<SExpr>,
    },
    Length {
        object: Box<SExpr>,
        integer: bool,
    },
    Math {
        op: String,
        name: String,
        args: Vec<SArrayItem>,
    },
    Cons {
        head: Box<SExpr>,
        tail: Box<SExpr>,
    },
    Nil,
    List {
        items: Vec<SExpr>,
    },
    Tag {
        tag: String,
    },
    Default,
}

Variants

Num

Fields

value: String

ty: Option<Type>

negative: bool

unit: bool

The 1 of x++, which takes the type of x.

Bool

Fields

value: bool

Str

Fields

value: String

Unit

Name

Fields

path: Vec<String>

DotCtor

Lean’s .ctor, resolved against the expected type.

Fields

name: String

App

Fields

func: Box<SExpr>

args: Vec<SExpr>

Field

Fields

object: Box<SExpr>

field: String

Unary

Fields

op: UnaryOp

arg: Box<SExpr>

Binary

Fields

op: BinaryOp

left: Box<SExpr>

right: Box<SExpr>

rounding: Option<Rounding>

If

Fields

cond: Box<SExpr>

then: Box<SExpr>

otherwise: Box<SExpr>

Let

Fields

name: String

ty: Option<Type>

value: Box<SExpr>

body: Box<SExpr>

Match

Fields

scrutinees: Vec<SExpr>

rows: Vec<SRow>

Match1

A single-level match, as pattern compilation produces it.

Fields

scrutinee: Box<SExpr>

cases: Vec<SCase>

ToString

Fields

arg: Box<SExpr>

Show

Fields

arg: Box<SExpr>

style: ShowStyle

Cast

Fields

arg: Box<SExpr>

to: Type

from: Option<Type>

flavor: Flavor

Abort

Fields

message: String

Print

console.log(expr), then body.

Fields

expr: Box<SExpr>

style: ShowStyle

body: Box<SExpr>

CtorObject

A JavaScript { $: 'tag', field: value } constructor object, fields in source order.

Fields

tag: String

fields: Vec<(String, SExpr)>

Array

A JavaScript array literal [a, ...xs, b].

Fields

items: Vec<SArrayItem>

element: Option<Type>

The element type inference fixed for a literal with no element of its own.

Index

xs[i], a read of an array element.

Fields

object: Box<SExpr>

index: Box<SExpr>

Length

The length of an array: a Number, or for the counter of a for…of loop a BigInt.

Fields

object: Box<SExpr>

integer: bool

Math

A call of a Math or Number function, Math.max(a, ...xs): op is the function and name the path the program called it by.

Fields

op: String

name: String

args: Vec<SArrayItem>

Cons

Fields

head: Box<SExpr>

tail: Box<SExpr>

Nil

List

Fields

items: Vec<SExpr>

Tag

Fields

tag: String

Default

Implementations

impl SNode

pub const fn kind(&self) -> &'static str

The k discriminant.

Trait Implementations

impl Clone for SNode

fn clone(&self) -> SNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SNode

impl PartialEq for SNode

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SNode