Struct SimpleScript

pub struct SimpleScript<'a> {
    pub simple: Simple<'a>,
    pub script: Script<'a>,
}

A simple expressiong with attached scripts

Fields

simple: Simple<'a>

The simple argument

script: Script<'a>

Any script modifications

Implementations

impl<'a> SimpleScript<'a>

pub fn new<S>(simple: S, script: Script<'a>) -> Self

where S: Into<Simple<'a>>,

Create a new simple script with a simple and script

pub fn without_scripts<S>(simple: S) -> Self

where S: Into<Simple<'a>>,

Create an unscripted simple expression

pub fn with_sub<S, Sub>(simple: S, sub: Sub) -> Self

where S: Into<Simple<'a>>, Sub: Into<Simple<'a>>,

Create a simple script with a subscript

pub fn with_super<S, Sup>(simple: S, sup: Sup) -> Self

where S: Into<Simple<'a>>, Sup: Into<Simple<'a>>,

Create a simple script with a super script

pub fn with_subsuper<S, Sub, Sup>(simple: S, sub: Sub, sup: Sup) -> Self

where S: Into<Simple<'a>>, Sub: Into<Simple<'a>>, Sup: Into<Simple<'a>>,

Create a simple script with sub and super scripts

Methods from Deref<Target = Script<'a>>

pub fn sub(&self) -> Option<&Simple<'a>>

Get the subscript

pub fn sup(&self) -> Option<&Simple<'a>>

Get the superscript

Trait Implementations

impl<'a> Clone for SimpleScript<'a>

fn clone(&self) -> SimpleScript<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SimpleScript<'a>

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

Formats the value using the given formatter.

impl<'a> Default for SimpleScript<'a>

fn default() -> SimpleScript<'a>

Returns the “default value” for a type.

impl<'a, S> From<S> for SimpleScript<'a>

where S: Into<Simple<'a>>,

fn from(inp: S) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for SimpleScript<'a>

fn eq(&self, other: &SimpleScript<'a>) -> 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<'a> Deref for SimpleScript<'a>

Add sub and super

type Target = Script<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> Eq for SimpleScript<'a>

impl<'a> StructuralPartialEq for SimpleScript<'a>