Struct DynamicArgument 

pub struct DynamicArgument<T> {
    pub origin: Origin,
    pub data: Cell,
    /* private fields */
}

A type of a function’s parameter that may have a more dynamic casting nature than usual.

The analyzer will assume that the argument’s type belongs to the type family of the T type, but the Script Engine will not automatically downcast the script’s argument, allowing the implementation to manually cast the argument’s Cell.

#[export]
fn plus_10(mut arg: DynamicArgument<usize>) -> RuntimeResult<usize> {
    let mut arg_ty = arg.data.type_match();

    if arg_ty.belongs_to::<usize>() {
        let arg = <usize>::downcast(arg.origin, Provider::Borrowed(&mut arg.data))?;

        return Ok(arg + 10);
    }

    if arg_ty.is::<str>() {
        let arg = arg.data.borrow_str(arg.origin)?;

        return Ok(arg.len() + 10);
    }

    Err(arg_ty.mismatch(arg.origin))
}

Fields

origin: Origin

A Rust or Script source code range where the argument has been provided.

data: Cell

The actual data of the argument.

Implementations

impl<T> DynamicArgument<T>

pub fn into_argument(self) -> Arg

A helper function that converts this instance into an operator’s argument.

Trait Implementations

impl<'a, T: ScriptType> Downcast<'a> for DynamicArgument<T>

fn downcast(origin: Origin, provider: Provider<'a>) -> RuntimeResult<Self>

Transforms Script data into Rust data.

fn hint() -> TypeHint

Returns a rough estimation of the Script type (or a set of types) from which the target Rust type could be inferred.