Struct cassie::Variable

pub struct Variable {
    pub symbol: char,
}

A variable represents a value which is arbitrary or unknown.

The assumption that this object will eventually be assigned a meaningful value is the basis of algebraic manipulation.

Fields

symbol: char

Methods

impl Variable

pub fn named(symbol: char) -> Self

Creates a variable with associated symbol symbol.

Examples

use cassie::Variable;
let x = Variable::named('x');
assert_eq!(x.symbol, 'x');
let v = Variable::named('ν');
assert_eq!(v.symbol, 'ν');

pub fn new(c: char) -> Self

An alias for Variable::named.

Examples

use cassie::Variable;
let x = Variable::new('x');
assert_eq!(x.symbol, 'x');
let v = Variable::new('ν');
assert_eq!(v.symbol, 'ν');

Trait Implementations

impl Clone for Variable

fn clone(&self) -> Variable

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for Variable

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

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

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

This method tests for !=.

impl Debug for Variable

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

Variables may be printed using the fmt::Debug trait.

Examples

use cassie::Variable;
let var = Variable::named('x');
assert_eq!(&format!("{:?}", var), "x");
let var = Variable::named('α');
assert_eq!(&format!("{:?}", var), "α");

impl FromStr for Variable

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Variable, Self::Err>

Variables may be constructed from string literals, provided that they are well-formed.

Examples

use cassie::Variable;
assert_eq!(Variable { symbol: 'x' }, "x".parse::<Variable>().unwrap());
assert_eq!(Variable { symbol: 'Γ' }, "Γ".parse::<Variable>().unwrap());
// Note that variable names must comprise exactly one character.
assert!("".parse::<Variable>().is_err());
assert!("xy".parse::<Variable>().is_err());