Struct gluon::compiler_pipeline::TypecheckValue

pub struct TypecheckValue<E> {
    pub expr: E,
    pub typ: ArcType,
    pub metadata_map: FnvMap<Symbol, Arc<Metadata>>,
    pub metadata: Arc<Metadata>,
}

Result type of successful typechecking

Fields

expr: E

typ: ArcType

metadata_map: FnvMap<Symbol, Arc<Metadata>>

metadata: Arc<Metadata>

Implementations

impl<E> TypecheckValue<E>

pub fn map<F>(self, f: impl FnOnce(E) -> F) -> TypecheckValue<F>

Trait Implementations

impl<E: Clone> Clone for TypecheckValue<E>

fn clone(&self) -> TypecheckValue<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'e, E, Extra> Compileable<Extra> for &'e TypecheckValue<E>

where E: Borrow<OwnedExpr<Symbol>> + Send + Sync, Extra: Send,

type Expr = &'e E

fn compile<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( self, compiler: &'life0 mut ModuleCompiler<'life1, 'life2>, thread: &'life3 Thread, filename: &'life4 str, _expr_str: &'life5 str, __arg5: Extra ) -> Pin<Box<dyn Future<Output = Result<CompileValue<Self::Expr>>> + Send + 'async_trait>>

where Extra: 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

impl<E, Extra> Compileable<Extra> for TypecheckValue<E>

where E: Borrow<OwnedExpr<Symbol>> + Send + Sync, Extra: Send,

type Expr = E

fn compile<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( self, compiler: &'life0 mut ModuleCompiler<'life1, 'life2>, thread: &'life3 Thread, filename: &'life4 str, expr_str: &'life5 str, extra: Extra ) -> Pin<Box<dyn Future<Output = Result<CompileValue<Self::Expr>>> + Send + 'async_trait>>

where Extra: 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

impl<E: Debug> Debug for TypecheckValue<E>

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

Formats the value using the given formatter.

impl<E: PartialEq> PartialEq for TypecheckValue<E>

fn eq(&self, other: &TypecheckValue<E>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Eq> Eq for TypecheckValue<E>

impl<E> StructuralEq for TypecheckValue<E>

impl<E> StructuralPartialEq for TypecheckValue<E>