Struct Notation

pub struct Notation {
    pub is_text: bool,
    pub precedence: isize,
    pub attribute_index: u8,
    pub inner_index: u16,
    pub id: Box<str>,
    pub argprecs: SmallVec<isize, 9>,
    pub components: Box<[NotationComponent]>,
    pub op: Option<OpNotation>,
}

Fields

is_text: bool

precedence: isize

attribute_index: u8

inner_index: u16

id: Box<str>

argprecs: SmallVec<isize, 9>

components: Box<[NotationComponent]>

op: Option<OpNotation>

Implementations

impl Notation

pub fn display_ftml<'a>( &'a self, op: bool, as_variable: bool, uri: &'a impl URITrait, ) -> impl Display + 'a

fn default_omid( out: &mut impl Write, tp: &str, uri: impl Display, txt: &str, in_text: bool, ) -> Result<(), PresentationError>

fn default_oma( presenter: &mut impl Presenter, tp: &str, uri: impl Display, txt: &str, args: &[Arg], ) -> Result<(), PresentationError>

pub(crate) fn present_term( term: &Term, presenter: &mut impl Presenter, ) -> Result<(), PresentationError>

Errors

fn informal( presenter: &mut impl Presenter, tag: &str, attributes: &[(Box<str>, Box<str>)], children: &[Informal], terms: &[Term], ) -> Result<(), PresentationError>

fn apply_op<W: Write>( &self, out: &mut W, termstr: &str, head: impl Display, args: &impl PresenterArgs<W>, insert_arg_attrs: bool, ) -> Result<(), PresentationError>

Errors

fn apply_op_this( &self, presenter: &mut impl Presenter, this: &Term, termstr: &str, head: impl Display, ) -> Result<(), PresentationError>

pub fn apply( &self, presenter: &mut impl Presenter, this: Option<&Term>, termstr: Option<&str>, head: impl Display, args: &[Arg], ) -> Result<(), PresentationError>

Errors

pub fn apply_cont<W: Write>( &self, out: &mut W, this: Option<&Term>, termstr: &str, head: impl Display, insert_arg_attrs: bool, args: &impl PresenterArgs<W>, ) -> Result<(), PresentationError>

Errors

impl Notation

pub fn is_op(&self) -> bool

Trait Implementations

impl AsRef<Notation> for Notation

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Notation

fn clone(&self) -> Notation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Notation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Notation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Notation

fn eq(&self, other: &Notation) -> 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 Notation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Notation

impl Resourcable for Notation

impl StructuralPartialEq for Notation