/*
Documented, #any
505684
public static <E> boolean any(final Iterable<E> iterable, final Predicate<E> pred) {
        return some(iterable, pred);
    }
131462
def any(pred: Callable, xs: Iterable):
    
    b = find_first(pred, xs)

    return True if b is not None else False
631275
public static <W extends WitnessType<W>,ST,A> EitherT<W,ST,A> of(final AnyM<W,Either<ST,A>> monads) {
        return new EitherT<>(
                                 monads);
    }
442615
public T or(Func0<T> func1) {
        return value != null ? value : func1.call();
    }
1360171
def _anydata_stmt(self, stmt: Statement, sctx: SchemaContext) -> None:
        """"""
        self._handle_child(AnydataNode(), stmt, sctx)
923024
public static <K, V> Predicate<Map<K, V>> anyEntry(
      Predicate<? super Map.Entry<K, V>> p) {
    return forEntries(Predicates.<Map.Entry<K, V>>any(p));
  }
1173423
def include_any?(*items)
      items = items.first if items.length == 1 && items.first.kind_of?(Array)
      !(self & items).empty?
    end
1267618
public static <T extends Tree> Matcher<T> anything() {
    return new Matcher<T>() {
      @Override
      public boolean matches(T t, VisitorState state) {
        return true;
      }
    };
  }
853854
@SuppressWarnings("unchecked")
    public static <T> Expression<T> any(SubQueryExpression<? extends T> col) {
        return new OperationImpl<T>(col.getType(), Ops.QuantOps.ANY, ImmutableList.<Expression<?>>of(col));
    }
350325
def any(cls, result_key, func):
        
        def scanner(self, obj):
            current_value = getattr(self, result_key, None)
            setattr(self, result_key, current_value or func(obj))

        cls._scan(result_key, scanner)
585094
def any_in_string(l, s):
    
    return any([i in l for i in l if i in s])
113650
public static <W extends WitnessType<W>,A> CompletableFutureT<W,A> fromAnyM(final AnyM<W,A> anyM) {
        return of(anyM.map(e-> {
            CompletableFuture<A> f = new CompletableFuture<A>();
           f.complete(e);
           return f;
        }));
    }
122042
public static <K, V> Predicate<Map<K, V>> anyKey(Predicate<? super K> p) {
    return forKeys(Predicates.<K>any(p));
  }
88640
public <E extends Exception> boolean anyMatch(Try.ShortPredicate<E> filter) throws E {
        return anyMatch(0, size(), filter);
    }
199497
def any(*validators):
    """"""
    def validate_any(fields):
        errors = {}
        for validator in validators:
            validation_errors = validator(fields)
            if not validation_errors:
                return
            errors.update(validation_errors)
        return errors

    validate_any.__doc__ = " or ".join(validator.__doc__ for validator in validators)
    return validate_any
583568
def any_of(value, *args):
    

    if len(args):
        value = (value,) + args

    return ExpectationAny(value)
1238587
@Override
    protected Expression or(Expression base, Expression expression) {
        return Expr.or(base, expression);
    }