Enum Expression 

pub enum Expression {
    Literal(Literal),
    Identifier(String),
    If {
        condition: Box<Expression>,
        then_branch: Box<Expression>,
        else_branch: Option<Box<Expression>>,
    },
    Match {
        expression: Box<Expression>,
        cases: Vec<MatchCase>,
    },
    Lambda {
        parameters: Vec<Parameter>,
        body: Box<Expression>,
    },
    Application {
        function: Box<Expression>,
        argument: Box<Expression>,
    },
    Binary {
        left: Box<Expression>,
        op: String,
        right: Box<Expression>,
    },
    Unary {
        op: String,
        operand: Box<Expression>,
    },
    Let {
        bindings: Vec<Binding>,
        body: Box<Expression>,
    },
    PipeForward {
        expression: Box<Expression>,
        function: Box<Expression>,
    },
    PipeBackward {
        function: Box<Expression>,
        expression: Box<Expression>,
    },
    Tuple(Vec<Expression>),
    List(Vec<Expression>),
    Array(Vec<Expression>),
    Record {
        type_name: Option<String>,
        fields: Vec<(String, Expression)>,
    },
    UnionCase {
        case_name: String,
        arguments: Vec<Expression>,
    },
    Sequential(Vec<Expression>),
    Parenthesized(Box<Expression>),
    Async(Box<Expression>),
    Computation {
        builder: String,
        body: Vec<ComputationItem>,
    },
}

F# expression

Variants

Literal(Literal)

Literal

Identifier(String)

Identifier

If

If expression

Fields

condition: Box<Expression>

Condition expression

then_branch: Box<Expression>

Then branch

else_branch: Option<Box<Expression>>

Else branch

Match

Match expression

Fields

expression: Box<Expression>

Expression to match

cases: Vec<MatchCase>

Match cases

Lambda

Lambda expression

Fields

parameters: Vec<Parameter>

Parameters

body: Box<Expression>

Body

Application

Function application

Fields

function: Box<Expression>

Function

argument: Box<Expression>

Argument

Binary

Binary expression

Fields

left: Box<Expression>

Left operand

op: String

Operator

right: Box<Expression>

Right operand

Unary

Unary expression

Fields

op: String

Operator

operand: Box<Expression>

Operand

Let

Let expression

Fields

bindings: Vec<Binding>

Bindings

body: Box<Expression>

Body

PipeForward

Pipe forward operator (|>)

Fields

expression: Box<Expression>

Expression

function: Box<Expression>

Function

PipeBackward

Pipe backward operator (<|)

Fields

function: Box<Expression>

Function

expression: Box<Expression>

Expression

Tuple(Vec<Expression>)

Tuple

List(Vec<Expression>)

List

Array(Vec<Expression>)

Array

Record

Record expression

Fields

type_name: Option<String>

Type name

fields: Vec<(String, Expression)>

Fields

UnionCase

Union case expression

Fields

case_name: String

Case name

arguments: Vec<Expression>

Arguments

Sequential(Vec<Expression>)

Sequential expressions

Parenthesized(Box<Expression>)

Parenthesized expression

Async(Box<Expression>)

Async expression

Computation

Computation expression

Fields

builder: String

Builder name

body: Vec<ComputationItem>

Body

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expression

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Expression

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 Expression