Walks the current expression and the children expressions.

@param callable $callback

@return void
188078
final public function walk(callable $callback)
    {
        $callback($this);

        foreach ($this->getChildren() as $child) {
            $child->walk($callback);
        }
    }
674981
protected function onStrategies(callable $callback)
    {
        $this->results = [];
        foreach ($this->strategies as $strategy) {
            $instance = $this->getStrategy($this->type, $strategy, $this->options);
            if ($instance) {
                $this->results[$strategy] = $callback($instance);
                if (!$this->checkResults($this->results[$strategy])) {
                    break;
                }
            } else {
                $this->results[$strategy] = true;
            }
        }

        return $this->results;
    }
464696
protected function prepareCallbacks(callable $callback/*, ... */) {
		list($init, $done, $then) = $this->getCallbacks();
		
		$context = $init();
		foreach (func_get_args() as $cb) {
			$then($context, $cb);
		}
		
		return array($context, function($result) use ($context, $done) {
			$done($context, $result);
		});
	}
828808
public function wrap_callback(callable $callback, array $args=[]) {
		self::$logger->debug(sprintf("Router: %s '%s'.",
			$this->request_method, $this->request_path));
		$callback($args);
		static::halt();
	}
1253531
public function callback(Closure $callback)
    {
        foreach ($this->getInnerIterator() as $key => $value) {
            yield $callback($value, $key);
        }
    }
1160584
public function explore(array &$array, callable $callback): void
    {
        array_walk($array, function (&$value, $key) use (&$array, $callback)
        {
            if (is_array($value))
            {
                $this->explore($value, $callback);
            }

            $callback($array, $key, $value);
        });
    }
919736
public function resolving($abstract, Closure $callback = null)
	{
		if ($callback === null && $abstract instanceof Closure)
		{
			$this->resolvingCallback($abstract);
		}
		else
		{
			$this->resolvingCallbacks[$abstract][] = $callback;
		}
	}
452077
public function listen(Closure $callback)
    {
        if (isset($this->events)) {
            $this->events->listen(Events\QueryExecuted::class, $callback);
        }
    }
458680
public function execute(callable $callback)
    {
        $commands = $this->commands;
        $command  = $this->client->createCommand('EXEC');

        $this->client->executeCommand($command, function ($responses, $client) use ($commands, $callback) {
            $size = count($responses);
            $processed = [];

            for ($i = 0; $i < $size; $i++) {
                $command  = $commands->dequeue();
                $response = $responses[$i];

                unset($responses[$i]);

                if (!$response instanceof ResponseInterface) {
                    $response = $command->parseResponse($response);
                }

                $processed[$i] = $response;
            }

            call_user_func($callback, $processed, $client);
        });
    }
953948
protected function _bind(array $callback) {
		if (true === empty($callback)) {
			return false;
		}
		array_map(function ($cb) {
			parent::on($cb['event'], $cb['callback']);
		}, $callback);
	}
265615
protected function walkEventList(array $events, callable $callback)
    {
        if (0 === \count($events)) {
            return;
        }
        /**
         * @var string     $eventName
         * @var array      $priorities
         * @var int|string $priority
         * @var array      $listeners
         * @var array      $listener
         */
        foreach ($events as $eventName => $priorities) {
            if (!\is_array($priorities) || 0 === \count($priorities)) {
                $mess = 'Must have as least one priority per listed event';
                throw new \LengthException($mess);
            }
            foreach ($priorities as $priority => $listeners) {
                if (!\is_array($listeners) || 0 === \count($listeners)) {
                    $mess = 'Must have at least one listener per listed priority';
                    throw new \LengthException($mess);
                }
                foreach ($listeners as $listener) {
                    $callback($eventName, $listener, $priority);
                }
            }
        }
    }
1300606
protected function callStringCallback($callback, $args = [])
    {
        if (strpos($callback, '@')) {
            list($klass, $method) = explode('@', $callback);
        } else {
            $klass  = $callback;
            $method = 'render';
        }

        $klass = isset($this->instantiatedWidgets[$klass]) ? $this->instantiatedWidgets[$klass] : new $klass;

        return call_user_func_array([$klass, $method], $args);
    }
495357
public function findChildren(callable $callback, $depth = null, $level = null)
    {

        $level = $level ?: 0;

        foreach ($this->children as $child) {

            /** @var NodeInterface $child */
            if ($child->is($callback))
                yield $child;

            if ($depth === null || $level < $depth) {

                if ($child instanceof NodeInterface)
                    foreach ($child->findChildren($callback, $depth, $level + 1) as $subChild)
                        yield $subChild;
            }
        }
    }
1061546
public function eachChild($callback)
    {
        foreach ($this->children as $child) {
            call_user_func($callback, $child);
        }

        return $this;
    }
1110130
public function map(callable $callback = null)
	{
		return $callback ? array_map($callback, $this->list) : $this->list;
	}
1321150
public function fatal(callable $callback)
    {
        $this->registerError(E_COMPILE_ERROR, $callback);
        $this->registerError(E_CORE_ERROR, $callback);
        $this->registerError(E_ERROR, $callback);
        $this->registerError(E_PARSE, $callback);
    }
117963
public function on ($event, callable $callback)
	{
		if (!isset ($this->events[$event]))
		{
			$this->events[$event] = array ();
		}
		$this->events[$event][] = $callback;
	}