Struct wolfram_expr::Expr

source · [−]

pub struct Expr { /* private fields */ }

Expand description

Wolfram Language expression.

Example

Construct the expression {1, 2, 3}:

use wolfram_expr::{Expr, Symbol};

let expr = Expr::normal(Symbol::new("System`List"), vec![
    Expr::from(1),
    Expr::from(2),
    Expr::from(3)
]);

Reference counting

Internally, Expr is an atomically reference-counted ExprKind. This makes cloning an expression computationally inexpensive.

Implementations

source

impl Expr

source

pub fn new(kind: ExprKind) -> Expr

Construct a new expression from an ExprKind.

source

pub fn to_kind(self) -> ExprKind

Consume self and return an owned ExprKind.

If the reference count of self is equal to 1 this function will not perform a clone of the stored ExprKind, making this operation very cheap in that case.

source

pub fn kind(&self) -> &ExprKind

Get the ExprKind representing this expression.

source

pub fn kind_mut(&mut self) -> &mut ExprKind

Get mutable access to the ExprKind that represents this expression.

If the reference count of the underlying shared pointer is not equal to 1, this will clone the ExprKind to make it unique.

source

pub fn ref_count(&self) -> usize

Retrieve the reference count of this expression.

source

pub fn normal<H: Into<Expr>>(head: H, contents: Vec<Expr>) -> Expr

Construct a new normal expression from the head and elements.

source

pub fn symbol<S: Into<Symbol>>(s: S) -> Expr

Construct a new expression from a Symbol.

source

pub fn number(num: Number) -> Expr

Construct a new expression from a Number.

source

pub fn string<S: Into<String>>(s: S) -> Expr

Construct a new expression from a String.

source

pub fn real(real: f64) -> Expr

Construct an expression from a floating-point number.

let expr = Expr::real(3.14159);

Panics

This function will panic if real is NaN.

source

pub fn tag(&self) -> Option<Symbol>

Returns the outer-most symbol “tag” used in this expression.

To illustrate:

Expression	Tag
`5`	`None`
`"hello"`	`None`
`foo`	`foo`
`f[1, 2, 3]`	`f`
`g[x][y]`	`g`

source

pub fn normal_head(&self) -> Option<Expr>

If this represents a Normal expression, return its head. Otherwise, return None.

source

pub fn normal_part(&self, index_0: usize) -> Option<&Expr>

Attempt to get the element at index of a Normal expression.

Return None if this is not a Normal expression, or the given index is out of bounds.

index is 0-based. The 0th index is the first element, not the head.

This function does not panic.

source

pub fn try_normal(&self) -> Option<&Normal>

If this is a Normal expression, return that. Otherwise return None.

source

pub fn try_symbol(&self) -> Option<&Symbol>

If this is a Symbol expression, return that. Otherwise return None.

source

pub fn try_number(&self) -> Option<Number>

If this is a Number expression, return that. Otherwise return None.

source

pub fn has_normal_head(&self, sym: &Symbol) -> bool

Returns true if self is a Normal expr with the head sym.

source

pub fn null() -> Expr

Null_WL.

Trait Implementations

source

impl Clone for Expr

source

fn clone(&self) -> Expr

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl Debug for Expr

source

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

Formats the value using the given formatter. Read more

source

By default, this should generate a string which can be unambiguously parsed to reconstruct the Expr being displayed. This means symbols will always include their contexts, special characters in String’s will always be properly escaped, and numeric literals needing precision and accuracy marks will have them.

source