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> AnnotSeqRef<'ast> for &'ast Annotation<'ast>

fn first(self) -> Option<&'ast Type<'ast>>

Returns the main annotation, which is either the type annotation if any, or the first contract annotation.

fn iter(self) -> impl Iterator<Item = &'ast Type<'ast>>

Iterates over the annotations, starting by the type and followed by the contracts.

fn typ(self) -> Option<&'ast Type<'ast>>

Returns the first type annotation, if any.

fn contracts(self) -> impl Iterator<Item = &'ast Type<'ast>>

Return the sequence of contracts, that is all annotations but the first type annotation, if any.

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> FromAst<Annotation<'ast>> for TypeAnnotation

fn from_ast(annot: &Annotation<'ast>) -> Self

impl<'ast> FromMainline<'ast, TypeAnnotation> for Annotation<'ast>

fn from_mainline(alloc: &'ast AstAlloc, annot: &TypeAnnotation) -> Self

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>