Trait EvalType 

pub trait EvalType: EvalTypeMethods + 'static {
    type RefType<'a>;

    // Required methods
    fn type_info() -> TypeInfo;
    fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>;
    fn register<Ctx: EvalType>(
        registry: RegistryAccess<'_, Ctx, Self>,
    ) -> Result<()>;

    // Provided method
    fn make_dyn_fn<Ctx: EvalType>(
        f: impl for<'a> Fn(&'a Ctx) -> Self::RefType<'a> + Clone + 'static,
    ) -> DynFn { ... }
}

Required Associated Types

type RefType<'a>

Required Methods

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

Provided Methods

fn make_dyn_fn<Ctx: EvalType>( f: impl for<'a> Fn(&'a Ctx) -> Self::RefType<'a> + Clone + 'static, ) -> DynFn

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl EvalType for f64

type RefType<'a> = f64

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl EvalType for i64

type RefType<'a> = i64

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl EvalType for ()

type RefType<'a> = ()

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( _registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl EvalType for String

type RefType<'a> = Cow<'a, str>

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl<T1, T2> EvalType for (T1, T2)

where T1: EvalType, T2: EvalType,

type RefType<'a> = &'a (T1, T2)

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( _registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl<T1, T2, T3> EvalType for (T1, T2, T3)

where T1: EvalType, T2: EvalType, T3: EvalType,

type RefType<'a> = &'a (T1, T2, T3)

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( _registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl<T1, T2, T3, T4> EvalType for (T1, T2, T3, T4)

where T1: EvalType, T2: EvalType, T3: EvalType, T4: EvalType,

type RefType<'a> = &'a (T1, T2, T3, T4)

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( _registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

impl<T1, T2, T3, T4, T5> EvalType for (T1, T2, T3, T4, T5)

where T1: EvalType, T2: EvalType, T3: EvalType, T4: EvalType, T5: EvalType,

type RefType<'a> = &'a (T1, T2, T3, T4, T5)

fn type_info() -> TypeInfo

fn to_ref_type<'a>(&'a self) -> Self::RefType<'a>

fn register<Ctx: EvalType>( _registry: RegistryAccess<'_, Ctx, Self>, ) -> Result<()>

Implementors