What does the anonymous function give me?

Question

I have in tutorial:

public function execute(BaseRequest $request)
{
    $operation = function() use($request) {
        return $this->service->execute($request);
    };

    return $this->session->executeAtomically(
        $operation->bindTo($this)
    );
}

What does the anonymous function give me?

Why can't I just do:

public function execute(BaseRequest $request)
{
    $operation = $this->service->execute($request);

    return $this->session->executeAtomically(
        $operation->bindTo($this)
    );
}

?

Answer 1

In this context, it defeats the purpose of anonymous functions however, they're used to extend the functions scope. Since the instance of the $request variable isn't being passed through the function, it would be inaccessible without the use(). Only anonymous functions allow the use() clause to be used, therefore in another context it would be useful if you have global variables which you don't want to continuously pass through a function.

Example:

$someDatabase = new PDO();

$doSomeQuery = function( $sql, $bind = [] ) use ( $someDatabase )
{
    $stmt = $someDatabase->Prepare( $sql );
    return $stmt->execute( $bind );
};

// Now we never have to pass the connection in which the developer may not need to know
foreach( $doSomeQuery( 'SELECT * FROM tbl WHERE col = ?', ['value'] )->fetchAll() as $row ) { ... }

Answer 2

I don't know what framework you're working with here, but my assumption is that executeAtomically has some setup and teardown logic included in it, probably starting and committing a database transaction. In such a case, you want the ultimate order of execution of your method to be:

1. Framework setup code is evaluated by $this->session->executeAtomically().
2. Your code ($this->service->execute($request);) is evaluated by $this->session->executeAtomically().
3. Framework teardown code is evaluated by $this->session->executeAtomically().

By evaluating the expression yourself rather than wrapping it in a closure, the code instead runs in the following order:

1. Your code is evaluated by your method.
2. Framework setup code is evaluated by $this->session->executeAtomically().
3. Framework teardown code is evaluated by $this->session->executeAtomically().

Most real-world use cases of closures involve some sort of delayed execution, either to perform setup/teardown logic, conduct "lazy loading", execute code multiple times as in a loop, etc.