Struct rlua::Function

pub struct Function<'lua>(/* private fields */);

Handle to an internal Lua function.

Implementations

impl<'lua> Function<'lua>

pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>( &self, args: A ) -> Result<R>

Calls the function, passing args as function arguments.

The function’s return values are converted to the generic type R.

Examples

Call Lua’s built-in tostring function:

let globals = lua_context.globals();

let tostring: Function = globals.get("tostring")?;

assert_eq!(tostring.call::<_, String>(123)?, "123");

Call a function with multiple arguments:

let sum: Function = lua_context.load(
    r#"
        function(a, b)
            return a + b
        end
    "#).eval()?;

assert_eq!(sum.call::<_, u32>((3, 4))?, 3 + 4);

pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>>

Returns a function that, when called, calls self, passing args as the first set of arguments.

If any arguments are passed to the returned function, they will be passed after args.

Examples

let sum: Function = lua_context.load(r#"
    function(a, b)
        return a + b
    end
"#).eval()?;

let bound_a = sum.bind(1)?;
assert_eq!(bound_a.call::<_, u32>(2)?, 1 + 2);

let bound_a_and_b = sum.bind(13)?.bind(57)?;
assert_eq!(bound_a_and_b.call::<_, u32>(())?, 13 + 57);

pub fn dump(&self) -> Result<Vec<u8>>

Dumps the compiled representation of the function into a binary blob, which can later be loaded using the unsafe Chunk::into_function_allow_binary().

Examples

let add2: Function = lua_context.load(r#"
    function(a)
        return a + 2
    end
"#).eval()?;

let dumped = add2.dump()?;

let reloaded = unsafe {
    lua_context.load(&dumped)
               .into_function_allow_binary()?
};
assert_eq!(reloaded.call::<_, u32>(7)?, 7+2);

Trait Implementations

impl<'lua> Clone for Function<'lua>

fn clone(&self) -> Function<'lua>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'lua> Debug for Function<'lua>

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

Formats the value using the given formatter.

impl<'lua> FromLua<'lua> for Function<'lua>

fn from_lua(value: Value<'lua>, _: Context<'lua>) -> Result<Function<'lua>>

Performs the conversion.

impl<'lua> ToLua<'lua> for Function<'lua>

fn to_lua(self, _: Context<'lua>) -> Result<Value<'lua>>

Performs the conversion.