Struct Expr

pub struct Expr { /* private fields */ }

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

impl Expr

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

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

pub fn try_as_bool(&self) -> Option<bool>

If this is a True or False symbol, return that. Otherwise return None.

pub fn try_as_str(&self) -> Option<&str>

If this is a ExprKind::String expression, return that. Otherwise return None.

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

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

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

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

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

👎Deprecated: Use Expr::try_as_normal() instead

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

👎Deprecated: Use Expr::try_as_symbol() instead

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

👎Deprecated: Use Expr::try_as_number() instead

impl Expr

pub fn new(kind: ExprKind) -> Expr

Construct a new expression from an ExprKind.

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.

pub fn kind(&self) -> &ExprKind

Get the ExprKind representing this expression.

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.

pub fn ref_count(&self) -> usize

Retrieve the reference count of this expression.

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

Construct a new normal expression from the head and elements.

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

Construct a new expression from a Symbol.

pub fn number(num: Number) -> Expr

Construct a new expression from a Number.

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

Construct a new expression from a String.

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.

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

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

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

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.

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

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

pub fn null() -> Expr

Null _WL.

pub fn rule<LHS: Into<Expr>>(lhs: LHS, rhs: Expr) -> Expr

Construct a new Rule[_, _] expression from the left-hand side and right-hand side.

Example

Construct the expression FontSize -> 16:

use wolfram_expr::{Expr, Symbol};

let option = Expr::rule(Symbol::new("System`FontSize"), Expr::from(16));

pub fn rule_delayed<LHS: Into<Expr>>(lhs: LHS, rhs: Expr) -> Expr

Construct a new RuleDelayed[_, _] expression from the left-hand side and right-hand side.

Example

Construct the expression x :> RandomReal[]:

use wolfram_expr::{Expr, Symbol};

let delayed = Expr::rule_delayed(
    Symbol::new("Global`x"),
    Expr::normal(Symbol::new("System`RandomReal"), vec![])
);

pub fn list(elements: Vec<Expr>) -> Expr

Construct a new List[...]({...}) expression from it’s elements.

Example

Construct the expression {1, 2, 3}:

use wolfram_expr::Expr;

let list = Expr::list(vec![Expr::from(1), Expr::from(2), Expr::from(3)]);

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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.

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

Formats the value using the given formatter.

impl From<&String> for Expr

fn from(s: &String) -> Expr

Converts to this type from the input type.

impl From<&Symbol> for Expr

fn from(sym: &Symbol) -> Expr

Converts to this type from the input type.

impl From<&str> for Expr

fn from(s: &str) -> Expr

Converts to this type from the input type.

impl From<Normal> for Expr

fn from(normal: Normal) -> Expr

Converts to this type from the input type.

impl From<String> for Expr

fn from(s: String) -> Expr

Converts to this type from the input type.

impl From<Symbol> for Expr

fn from(sym: Symbol) -> Expr

Converts to this type from the input type.

impl From<bool> for Expr

fn from(value: bool) -> Expr

Converts to this type from the input type.

impl From<i16> for Expr

fn from(int: i16) -> Expr

Converts to this type from the input type.

impl From<i32> for Expr

fn from(int: i32) -> Expr

Converts to this type from the input type.

impl From<i64> for Expr

fn from(int: i64) -> Expr

Converts to this type from the input type.

impl From<i8> for Expr

fn from(int: i8) -> Expr

Converts to this type from the input type.

impl From<u16> for Expr

fn from(int: u16) -> Expr

Converts to this type from the input type.

impl From<u32> for Expr

fn from(int: u32) -> Expr

Converts to this type from the input type.

impl From<u8> for Expr

fn from(int: u8) -> Expr

Converts to this type from the input type.

impl Hash for Expr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Symbol> for Expr

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

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

const 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 PartialEq for Expr

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

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

const 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 Eq for Expr

impl StructuralPartialEq for Expr