Struct ext_php_rs::closure::Closure

pub struct Closure(_);

Available on crate feature closure only.

Wrapper around a Rust closure, which can be exported to PHP.

Closures can have up to 8 parameters, all must implement FromZval, and can return anything that implements IntoZval. Closures must have a static lifetime, and therefore cannot modify any self references.

Internally, closures are implemented as a PHP class. A class RustClosure is registered with an __invoke method:

<?php

class RustClosure {
    public function __invoke(...$args): mixed {
        // ...    
    }
}

The Rust closure is then double boxed, firstly as a Box<dyn Fn(...) -> ...> (depending on the signature of the closure) and then finally boxed as a Box<dyn PhpClosure>. This is a workaround, as PhpClosure is not generically implementable on types that implement Fn(T, ...) -> Ret. Make a suggestion issue if you have a better idea of implementing this!.

When the __invoke method is called from PHP, the invoke method is called on the dyn PhpClosure\ trait object, and from there everything is basically the same as a regular PHP function.

Implementations

impl Closure

pub fn wrap<T>(func: T) -> Selfwhere
    T: PhpClosure + 'static,

Wraps a Fn or FnMut Rust closure into a type which can be returned to PHP.

The closure can accept up to 8 arguments which implement IntoZval, and can return any type which implements FromZval. The closure must have a static lifetime, so cannot reference self.

Parameters

• func - The closure to wrap. Should be boxed in the form Box<dyn Fn[Mut](...) -> ...>.

Example

use ext_php_rs::closure::Closure;

let closure = Closure::wrap(Box::new(|name| {
    format!("Hello {}", name)
}) as Box<dyn Fn(String) -> String>);

Examples found in repository

src/closure.rs (lines 221-234)

    fn into_closure(self) -> Closure {
        let mut this = Some(self);

        Closure::wrap(Box::new(move || {
            let this = match this.take() {
                Some(this) => this,
                None => {
                    let _ = PhpException::default(
                        "Attempted to call `FnOnce` closure more than once.".into(),
                    )
                    .throw();
                    return Option::<R>::None;
                }
            };

            Some(this())
        }) as Box<dyn FnMut() -> Option<R>>)
    }

pub fn wrap_once<T>(func: T) -> Selfwhere
    T: PhpOnceClosure + 'static,

Wraps a FnOnce Rust closure into a type which can be returned to PHP. If the closure is called more than once from PHP, an exception is thrown.

The closure can accept up to 8 arguments which implement IntoZval, and can return any type which implements FromZval. The closure must have a static lifetime, so cannot reference self.

Parameters

• func - The closure to wrap. Should be boxed in the form Box<dyn FnOnce(...) -> ...>.

Example

use ext_php_rs::closure::Closure;

let name: String = "Hello world".into();
let closure = Closure::wrap_once(Box::new(|| {
    name
}) as Box<dyn FnOnce() -> String>);

pub fn build()

Builds the class entry for Closure, registering it with PHP. This function should only be called once inside your module startup function.

Panics

Panics if the function is called more than once.

Trait Implementations

impl<'a> FromZendObject<'a> for &'a Closure

fn from_zend_object(obj: &'a ZendObject) -> Result<Self>

Extracts Self from the source ZendObject.

impl<'a> FromZendObjectMut<'a> for &'a mut Closure

fn from_zend_object_mut(obj: &'a mut ZendObject) -> Result<Self>

Extracts Self from the source ZendObject.

impl<'a> FromZval<'a> for &'a Closure

const TYPE: DataType = _

The corresponding type of the implemented value in PHP.

fn from_zval(zval: &'a Zval) -> Option<Self>

Attempts to retrieve an instance of Self from a reference to a Zval.

impl<'a> FromZvalMut<'a> for &'a mut Closure

const TYPE: DataType = _

The corresponding type of the implemented value in PHP.

fn from_zval_mut(zval: &'a mut Zval) -> Option<Self>

Attempts to retrieve an instance of Self from a mutable reference to a Zval.

impl IntoZendObject for Closure

fn into_zend_object(self) -> Result<ZBox<ZendObject>>

Attempts to convert self into a Zend object.

impl IntoZval for Closure

const TYPE: DataType = _

The corresponding type of the implemented value in PHP.

fn set_zval(self, zv: &mut Zval, persistent: bool) -> Result<()>

Sets the content of a pre-existing zval. Returns a result containing nothing if setting the content was successful.

fn into_zval(self, persistent: bool) -> Result<Zval>

Converts a Rust primitive type into a Zval. Returns a result containing the Zval if successful.

impl RegisteredClass for Closure

const CLASS_NAME: &'static str = "RustClosure"

PHP class name of the registered class.

fn get_metadata() -> &'static ClassMetadata<Self>

Returns a reference to the class metadata, which stores the class entry and handlers.

fn get_properties<'a>() -> HashMap<&'static str, Property<'a, Self>>

Returns a hash table containing the properties of the class.

const CONSTRUCTOR: Option<ConstructorMeta<Self>> = None

Optional class constructor.

impl Send for Closure

impl Sync for Closure