Return true if any $predicate returns value is true

@param callable $predicate
@return boolean
499608
public function any(callable $predicate)
    {
        foreach ($this->each() as $k => $v) {
            if ($predicate($v, $k)) {
                return true;
            }
        }
        return false;
    }
131462
def any(pred: Callable, xs: Iterable):
    
    b = find_first(pred, xs)

    return True if b is not None else False
396394
public static <T> T detectIfNone(Iterable<T> iterable, Predicate<? super T> predicate, T ifNone)
    {
        T result = Iterate.detect(iterable, predicate);
        return result == null ? ifNone : result;
    }
1098727
public function resolvePredicate(Predicate $predicate) {
        $this->_bindings = array_merge($this->_bindings, $predicate->getBindings());

        return $this;
    }
102092
public function is($value)
    {
        if ($value === null) {
            return $this->isNull();
        }

        if (\is_array($value)) {
            return $this->in($value);
        }

        $this->predicates[] = $this->processValue($value);

        return $this;
    }
223829
public static function all(array $array, callable $predicate)
    {
        foreach ($array as $key => $value) {
            if (! $predicate($value, $key, $array)) {
                return false;
            }
        }

        return true;
    }
798431
public function withTransaction(callable $callable)
    {
        try {
            $nested = $this->transactionStarted;
            if (!$nested) {
                $this->startTransaction();
            }
            $this->transactionStarted = true;
            $result = $callable();
            if (!$nested) {
                $this->commit();
            }
            $this->transactionStarted = $nested;
            return $result;
        } catch (Throwable $e) {
            if ($this->transactionStarted) {
                $this->rollback();
                $this->transactionStarted = false;
            }
            throw $e;
        }
    }
83950
public function getObject($subject, $predicate)
    {
        $returnValue = null;

        
    	$sqlQuery = "SELECT object FROM statements WHERE subject = ? AND predicate = ?";
		$dbWrapper = core_kernel_classes_DbWrapper::singleton();
		$sqlResult = $dbWrapper->query($sqlQuery, array (
			$subject,
			$predicate
		));
		$returnValue = new core_kernel_classes_ContainerCollection(new common_Object(__METHOD__));
		while ($row = $sqlResult->fetch()){
			
			$value = $row['object'];
			if(!common_Utils::isUri($value)) {
				$container = new core_kernel_classes_Literal($value);
			}
			else{
				$container = new core_kernel_classes_Resource($value);
			}
			$container->debug = __METHOD__ ;
			$returnValue->add($container);
		}
        

        return $returnValue;
    }
983928
public function isCallable($c)
    {
        if (is_string($c)) {
            return false;
        }
        if (is_object($c) && is_callable($c)) {
            return true;
        }

        return is_array($c) && isset($c[0]) && is_object($c[0]) && is_callable($c);
    }
866076
public static function some (array $sequence, $predicate)
    {
        foreach ($sequence as $element) {
            if (call_user_func($predicate, $element)) {
                return true;
            }
        }
        return false;
    }
205595
public function takeUntil(callable $predicate)
    {
        return $this->takeWhile(
            function ($value, $key, $iterable) use ($predicate) {
                return !$predicate($value, $key, $iterable);
            }
        );
    }
405516
public function formatSubPredicate(Predicate $predicate) {
        $output = [];

        foreach ($predicate->getParams() as $param) {
            if ($param instanceof Predicate) {
                $output[] = $this->formatSubPredicate($param);

            } else if ($param instanceof Expr) {
                $output[] = $this->formatExpression($param);
            }
        }

        return [
            $this->getClause($predicate->getType()) => $output
        ];
    }
618170
public boolean every(Func1<? super T, Boolean> predicate) {
        for (T item : this) {
            if (!predicate.call(item))
                return false;
        }
        return true;
    }
1107951
function AnyAllPredicate(op, expr, pred) {
      this.op = this._resolveOp(op);
      this.exprSource = expr;
      // this.expr will not be resolved until validate is called
      this.pred = Predicate(pred);
    }
972594
public function filter(callable $predicate): self
    {
        $intervals = array_filter($this->intervals, $predicate, ARRAY_FILTER_USE_BOTH);
        if ($intervals === $this->intervals) {
            return $this;
        }

        return new self(...$intervals);
    }
35971
public static <T> Predicate<T> TRUE() {
	return new Predicate<T>() {
	    public boolean check(T obj) { return true; }
	};
    }
1146599
public final FluentCloseableIterable<T> filter(Predicate<? super T> predicate) {
        return from(CloseableIterables.filter(this, predicate));
    }