/**
  * Get service instance
  *
  * @param ServiceLocatorInterface $serviceLocator Service Locator instance
  * @return mixed
  */
 public function getServiceInstance(ServiceLocatorInterface $serviceLocator)
 {
     if ($this->instance === null) {
         /**
          * Instance must be created using factory
          */
         if ($this->factory instanceof \Closure) {
             $instance = call_user_func($this->factory, $serviceLocator);
         } else {
             $instance = $this->factory->factory($serviceLocator);
         }
         if (!$this->isShared()) {
             return $instance;
             // new instance must be returned
         } else {
             $this->instance = $instance;
             // cache instance
             return $this->instance;
             // same instance must be returned
         }
     } else {
         /**
          * Instance either was passed directly or has been created earlier
          */
         if (!$this->isShared()) {
             return $this->instance;
             // new instance must be returned
         } else {
             return clone $this->instance;
             // same instance must be returned
         }
     }
 }

 /**
  * @param string $type
  * @param \Closure $generateImage
  * @param \Closure $checkOutput
  * @param array $logLevels
  * @dataProvider imageProvider
  */
 public function testCorrect(string $type, \Closure $generateImage, \Closure $checkOutput, array $logLevels = [])
 {
     $validator = new ImageValidator($type, '');
     $validator->setLogger($this);
     $checkOutput->call($this, $validator->correct($generateImage()));
     $this->assertEquals($logLevels, $this->logLevels);
 }

 public function on($event, \Closure $callback)
 {
     if (is_string($event)) {
         $this->events[$event] = $callback->bindTo($this, $this);
     }
     return $this;
 }

 /**
  * Invokes original method and return result from it
  *
  * @return mixed
  */
 public function proceed()
 {
     if (isset($this->advices[$this->current])) {
         /** @var $currentInterceptor \Go\Aop\Intercept\Interceptor */
         $currentInterceptor = $this->advices[$this->current++];
         return $currentInterceptor->invoke($this);
     }
     // Fill the closure only once if it's empty
     if (!$this->closureToCall) {
         $this->closureToCall = $this->reflectionMethod->getClosure($this->instance);
     }
     // Rebind the closure if instance was changed since last time
     if ($this->previousInstance !== $this->instance) {
         $this->closureToCall = $this->closureToCall->bindTo($this->instance, $this->reflectionMethod->class);
         $this->previousInstance = $this->instance;
     }
     $closureToCall = $this->closureToCall;
     $args = $this->arguments;
     switch (count($args)) {
         case 0:
             return $closureToCall();
         case 1:
             return $closureToCall($args[0]);
         case 2:
             return $closureToCall($args[0], $args[1]);
         case 3:
             return $closureToCall($args[0], $args[1], $args[2]);
         case 4:
             return $closureToCall($args[0], $args[1], $args[2], $args[3]);
         case 5:
             return $closureToCall($args[0], $args[1], $args[2], $args[3], $args[4]);
         default:
             return forward_static_call_array($closureToCall, $args);
     }
 }

 public function get()
 {
     if (!$this->closure instanceof \Closure) {
         throw new \RuntimeException("Cannot get a key with an undefined closure");
     }
     if ($this->enabled) {
         $data = $this->predis->get($this->getKeyName($this->key));
     }
     if ($data === null) {
         $boundCallback = $this->closure->bindTo($this);
         $data = $boundCallback();
         if ($this->enabled) {
             $this->predis->setex($this->getKeyName($this->key), $this->ttl, serialize($data));
         }
         if ($this->onMiss instanceof \Closure) {
             call_user_func_array($this->onMiss, [$this, $data]);
         }
         return $data;
     } else {
         $value = unserialize($data);
         if ($this->onHit instanceof \Closure) {
             call_user_func_array($this->onHit, [$this, $value]);
         }
         return $value;
     }
 }

 /**
  * Constructs a Spec, to be associated with a particular suite, and ran
  * by the test runner. The closure is bound to the suite.
  *
  * @param string   $title   A title to be associated with the spec
  * @param \Closure $closure The closure to invoke when the spec is called
  * @param Suite    $suite   The suite within which this spec was defined
  */
 public function __construct($title, \Closure $closure = null, Suite $suite)
 {
     $this->title = $title;
     $this->suite = $suite;
     if ($closure) {
         $this->closure = $closure->bindTo($suite);
     }
 }

function myCapture(Closure $closure)
{
    ob_start();
    $closure->__invoke();
    $contents = ob_get_contents();
    ob_end_clean();
    return $contents;
}

 public function fingerprint(\Closure $fingerprint = null)
 {
     if (func_num_args() > 0) {
         $this->_fingerprint = $fingerprint->bindTo($this);
         return $this;
     }
     return $this->_fingerprint;
 }

 /**
  * Registers a route.
  *
  * @param  string $name
  * @param  \Closure $handler
  *
  * @return Route
  */
 public function add($name, \Closure $handler)
 {
     // Bind the handler to the Router class
     $route = new Route($name, $handler->bindTo($this, $this));
     // Insert the route
     $this->routes[$name] = $route;
     return $route;
 }

 /**
  * @param string $prefix
  * @param \Closure $closure
  */
 public function group($prefix, \Closure $closure)
 {
     $original = $this->prefix;
     $this->prefix = sprintf('/%s/%s', trim($original, '/'), trim($prefix, '/'));
     $callback = $closure->bindTo($this);
     $callback();
     $this->prefix = $original;
 }

 public function __construct(\Closure $closure, Suite $suite)
 {
     $this->suite = $suite;
     if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
         $this->closure = $closure->bindTo($suite);
     } else {
         $this->closure = $closure;
     }
 }

 /**
  * Retrieves data by key or executes $callback in case of cache miss. Data returned
  * by $callback is then cached.
  *
  *     \rox\Cache::fetch('my_key', '+1 hour', function(){
  *         // some expensive operation
  *         return $results;
  *     });
  *
  * @param string $key 
  * @param string $expires expiration time in seconds or strtotime() compatible string
  * @param \Closure $callback closure to be executed on cache miss
  * @return mixed
  */
 public static function fetch($key, $expires, \Closure $callback)
 {
     $data = static::read($key);
     if ($data === false) {
         $data = $callback->__invoke();
         static::write($key, $data, $expires);
     }
     return $data;
 }

 /**
  * Executes a legacy kernel callback
  *
  * Does the callback with both post-reinitialize and formtoken checks disabled.
  *
  * @param callable $callback
  *
  * @return mixed
  */
 protected function runLegacyKernelCallback($callback)
 {
     // Initialize legacy kernel if not already done
     if ($this->legacyKernel instanceof Closure) {
         $legacyKernelClosure = $this->legacyKernel;
         $this->legacyKernel = $legacyKernelClosure();
     }
     return $this->legacyKernel->runCallback($callback, false, false);
 }

 /**
  * Build where clause response.
  *
  * @param  Closure|bool  $expectation
  * @return mixed
  */
 private function mockFindUserResponse($expectation)
 {
     if (!$expectation instanceof Closure) {
         return $expectation;
     }
     $user = Mockery::mock(User::class);
     // Run the expectations for the returned user mock.
     $expectation->__invoke($user);
     return $user;
 }

 /**
  * Attach a handler to the session validator chain
  * 
  * @param  string $topic 
  * @param  string|object|Closure $context 
  * @param  null|string $handler 
  * @return Zend\Stdlib\SignalHandler
  */
 public function connect($topic, $context, $handler = null)
 {
     if ($context instanceof Validator) {
         $data = $context->getData();
         $name = $context->getName();
         $this->getStorage()->setMetadata('_VALID', array($name => $data));
     }
     $handle = parent::connect($topic, $context, $handler);
     return $handle;
 }

 public function testRepoIsPassedToTheClosureAsFirstParameter()
 {
     $repo = $this->getRepo('foobar');
     $self = $this;
     $criterion = new Closure(function ($param) use($repo, $self) {
         $self->assertEquals($repo, $param);
         return $param === $repo;
     });
     $this->assertTrue($criterion->matches($repo));
 }

 /**
  * Constructs a test suite, which may contain nested suites and specs. The
  * anonymous function passed to the constructor contains the body of the
  * suite to be ran, and it is bound to the suite.
  *
  * @param string   $title   A title to be associated with the suite
  * @param \Closure $closure The closure to invoke when the suite is ran
  * @param Suite    $parent  An optional parent suite
  */
 public function __construct($title, \Closure $closure, Suite $parent = null)
 {
     $this->title = $title;
     $this->closure = $closure->bindTo($this);
     $this->specs = [];
     $this->suites = [];
     $this->store = [];
     $this->parent = $parent;
     $this->pending = false;
 }

 /**
  * Constructs a Spec, to be associated with a particular suite, and ran
  * by the test runner. The closure is bound to the suite.
  *
  * @param string   $title   A title to be associated with the spec
  * @param \Closure $closure The closure to invoke when the spec is called
  * @param Suite    $suite   The suite within which this spec was defined
  */
 public function __construct($title, \Closure $closure = null, Suite $suite)
 {
     $this->title = $title;
     $this->suite = $suite;
     if ($closure && version_compare(PHP_VERSION, '5.4.0', '>=')) {
         $this->closure = $closure->bindTo($suite);
     } else {
         if ($closure) {
             $this->closure = $closure;
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function __invoke($input, $index)
 {
     /** @noinspection PhpMethodParametersCountMismatchInspection */
     /** @noinspection PhpMethodParametersCountMismatchInspection */
     /** @noinspection PhpVoidFunctionResultUsedInspection */
     return $this->function->__invoke($input, $index);
 }

 public static final function entityManager()
 {
     if (self::$entityManager === null) {
         self::$entityManager = self::$entityManagerFactory->__invoke();
     }
     return self::$entityManager;
 }