Delete delete işlemlerinde kullanılır

@param string $table
@param callable $callable
@return mixed
420063
public function delete($table, callable $callable = null)
    {
        $this->connect($table);
        $delete = new Delete($this);

        return $callable($delete);
    }
573109
final public function run($callable = null)
    {
        // 请求开始之前响应事件
        if ($this->hasEventHandler('beginRequest')) {
            $this->onBeginRequest(new Event($this));
        }

        // 定义程序最终都会执行到 end
        register_shutdown_function([$this, 'end'], 0, false);

        if (false !== $this->beforeRun($callable)) {
            // 请求处理
            $this->processRequest();
        }
    }
879033
public function delete(string $pattern, callable $callback)
    {
        if ($this->requestMethod === "DELETE") {
            $this->mapRoute($pattern, $callback);
        }
    }
134105
public function join($table, callable $callabe = null)
    {
        $table = $this->getPrefix().$table;

        if (is_null($this->join)) {
            $this->join = 'inner join `'.$table.'`';
        } else {
            $this->join .= ', `'.$table.'`';
        }

        if (is_callable($callabe)) {
            $callabe($this);
        }

        return $this;
    }
447872
public function delete(string $table): Query\Delete
    {
        $query = new Query\Delete();
        $query->delete($table);
        return $query;
    }
944371
public function map(callable $callable)
    {
        $keys = $this->keys();
        $items = array_map($callable, $this->attributes, $keys);

        return new static(array_combine($keys, $items));
    }
927745
protected function executeCallable($callable, array $arguments = [])
    {
        // resolve a pseudo callable to real callable
        $call = $this->resolvePseudoCallable($callable);

        // execute the callable
        return call_user_func_array(
            $call,
            $this->resolveCallableArguments($call, $arguments)
        );
    }
931448
public function register($key, $callable)
	{
		if (!$this->has($key) && is_callable($callable))
		{
			self::$registry[$key] = $callable;
			return true;
		}

		return false;
	}
1061619
public function getElseSet(string $key, int $ttl, callable $callable)
    {
        if ($this->exists($key)) {
            return $this->get($key);
        }

        try {
            $callable_data = call_user_func($callable);
        } catch( Exception $e ) {
            // throw exception
        }

        $this->set($key, $callable_data);
        $this->expireAt($key, time() + $ttl);

        return $this->get($key);
    }
719709
public function extend($name, callable $callable)
    {
        if ($this->parent) {
            $this->parent->extend($name, $callable);
        }

        if ($callable instanceof Closure) {
            $callable = $callable->bindTo($this);
        }

        $this->callables[$name] = $callable;

        return $this;
    }
685889
public function setCallable($callable)
    {
        $matches = array();
        if (is_string($callable) && preg_match('!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!', $callable, $matches)) {
            $class = $matches[1];
            $method = $matches[2];
            $callable = function() use ($class, $method) {
                static $obj = null;
                if ($obj === null) {
                    $obj = new $class;
                }
                return call_user_func_array(array($obj, $method), func_get_args());
            };
        }

        if (!is_callable($callable)) {
            throw new \InvalidArgumentException('Route callable must be callable');
        }

        $this->callable = $callable;
    }
662743
public static function call(callable $callable, $args=null)
    {

        if (!is_array($args)) {
            $args = $args === null ? [] : [$args];
        }

        return static::callFast($callable, static::evaluateArgs($args));

    }
747362
public function containsCallable(callable $callable)
	{
		foreach ($this->routes as $method) {
			foreach ($method as $entry)
			{
				if ($entry->callable === $callable) {
					return true;
				}
			}
		}

		return false;
	}
423335
public function delete(string $table, string $id): bool
    {
        return $this->deleteWhere($table, 'id', $id);
    }
808195
public function call($key, $callable)
    {
        if (!is_callable($callable)) {
            throw new \InvalidArgumentException('Not a valid callable.');
        }

        if ($this->exists($key)) {
            return $this->get($key);
        }

        $args = func_get_args();
        array_shift($args);
        array_shift($args);

        $value = call_user_func_array($callable, $args);

        $this->set($key, $value);

        return $value;
    }
182800
protected function filterCallable($callable, TransitionEvent $event)
    {
        if (is_array($callable) && isset($callable[0]) && is_string($callable[0]) && 'object' === substr($callable[0], 0, 6)) {
            $object = $event->getStateMachine()->getObject();

            // callable could be "object.property" and not just "object", so we evaluate the "property" path
            if ('object' !== $callable[0]) {
                $accessor = new PropertyAccessor();
                $object = $accessor->getValue($object, substr($callable[0], 7));
            }

            return array($object, $callable[1]);
        }

        return $callable;
    }
522247
public function filter(callable $callable)
    {
        $result = [];

        foreach ($this->value as $key => $value) {
            if ($callable($value, $key, $this)) {
                $result[$key] = $value;
            }
        }

        return static::of($result);
    }