Struct Annotation 

pub struct Annotation<'ast> {
    pub typ: Option<Type<'ast>>,
    pub contracts: &'ast [Type<'ast>],
}

A type and/or contract annotation.

Fields

typ: Option<Type<'ast>>

The type annotation (using :).

contracts: &'ast [Type<'ast>]

The contract annotations (using |).

Implementations

impl Annotation<'_>

pub fn contracts_to_string(&self) -> Option<String>

Returns a string representation of the contracts (without the static type annotation) as a comma-separated list.

pub fn is_empty(&self) -> bool

Returns true if this annotation is empty, i.e. hold neither a type annotation nor contracts annotations.

Trait Implementations

impl<'ast> AttachToAst<'ast, Ast<'ast>> for Annotation<'ast>

fn attach_to_ast(self, alloc: &'ast AstAlloc, ast: Ast<'ast>) -> Ast<'ast>

impl<'ast> Clone for Annotation<'ast>

fn clone(&self) -> Annotation<'ast>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for Annotation<'_>

type Data<'ast> = Annotation<'ast>

This is always Self, be we need associated types to make Rust understand that Self is always parametric over the 'ast lifetime. We’re using GATs to emulate higher-kinded types.

fn clone_to<'to>(data: Self::Data<'_>, dest: &'to AstAlloc) -> Self::Data<'to>

Clones owned data from the current allocator to dest.

impl<'ast> Combine<'ast> for Annotation<'ast>

fn combine(alloc: &'ast AstAlloc, left: Self, right: Self) -> Self

Combine two annotations. If both have types set, the final type is the one of the left annotation, while the right one’s type is put inside the final contracts.

Contracts are combined from left to right; the left one’s are put first, then maybe the right one’s type annotation and then the right one’s contracts.

impl<'ast> CombineAlloc<'ast> for Annotation<'ast>

fn combine(alloc: &'ast AstAlloc, left: Self, right: Self) -> Self

Combine two annotations. If both have types set, the final type is the one of the left annotation, while the right one’s type is put inside the final contracts.

Contracts are combined from left to right; the left one’s are put first, then maybe the right one’s type annotation and then the right one’s contracts.

impl<'ast> Debug for Annotation<'ast>

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

Formats the value using the given formatter.

impl<'ast> Default for Annotation<'ast>

fn default() -> Annotation<'ast>

Returns the “default value” for a type.

impl<'ast> From<Annotation<'ast>> for FieldMetadata<'ast>

fn from(annotation: Annotation<'ast>) -> Self

Converts to this type from the input type.

impl<'ast> PartialEq for Annotation<'ast>

fn eq(&self, other: &Annotation<'ast>) -> 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<'a> Pretty<'a, Allocator> for &Annotation<'_>

fn pretty(self, allocator: &'a Allocator) -> DocBuilder<'a, Allocator>

Converts self into a document

impl<'ast> TraverseAlloc<'ast, Ast<'ast>> for Annotation<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<Self, E>

where F: FnMut(Ast<'ast>) -> Result<Ast<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Ast<'ast>, &S) -> TraverseControl<S, U>, scope: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl Allocable for Annotation<'_>

impl<'ast> Eq for Annotation<'ast>

impl<'ast> StructuralPartialEq for Annotation<'ast>