and : (a -> Boolean) | Pred -> (a -> Boolean) | Pred -> a -> Boolean
494699
function and(f, g) {
  if(!(isPredOrFunc(f) && isPredOrFunc(g))) {
    throw new TypeError(
      'and: Preds or predicate functions required for first two arguments'
    )
  }

  return x => !!(predOrFunc(f, x) && predOrFunc(g, x))
}
405173
public static Boolean and(Boolean a, Boolean b) 
  {
    return andTable[ttIndex(a)][ttIndex(b)];
  }
310740
function AND(args) {
  args = args.slice()
  let right
  let left = args.shift()
  while (args.length) {
    right = args.shift()
    left = E.LOGICAL(left, '&&', right)
  }

  return left
}
1118619
public static <T1, T2> BiPredicate<T1, T2> or(BiPredicate<T1, T2> first, BiPredicate<T1, T2> second, BiPredicate<T1, T2> third) {
        dbc.precondition(first != null, "first predicate is null");
        dbc.precondition(second != null, "second predicate is null");
        dbc.precondition(third != null, "third predicate is null");
        return Logic.Binary.or(Iterations.iterable(first, second, third));
    }
131462
def any(pred: Callable, xs: Iterable):
    
    b = find_first(pred, xs)

    return True if b is not None else False
717446
public static <E> boolean all(final Iterable<E> iterable, final Predicate<E> pred) {
        return every(iterable, pred);
    }
647341
function and(values, values2) {
    var results = [];
    if(values instanceof Array) {
        for(var i=0; i<values.length; i++) {
            results.push(values[i]);
        }
    }
    if(values2 instanceof Array) {
        for(var i=0; i<values2.length; i++) {
            results.push(values2[i]);
        }
    }
    return results;
}
288061
public static And and(Expression<Boolean> left, Expression<Boolean> right) {
        return new And(left, right);
    }
974075
private Expression parseBooleanExpression(Expression expr) {
    if (tokens.positiveLookahead(AND)) {
      tokens.consume();
      expr = new And(expr, parseSemVerExpression());
    } else if (tokens.positiveLookahead(OR)) {
      tokens.consume();
      expr = new Or(expr, parseSemVerExpression());
    }
    return expr;
  }
622563
def bool_set(operation,*sets):
    ''''''
    if len(sets)<=1:
        return sets
    if operation=='and':
        return and_sets(*sets)
    if operation=='or':
        return or_sets(*sets)
    if operation=='not':
        return not_sets(*sets)
946519
public static boolean and(EvaluationContext ctx, Object... args) {
        for (Object arg : args) {
            if (!Conversions.toBoolean(arg, ctx)) {
                return false;
            }
        }
        return true;
    }
1327706
function(and, or) {
			var aIntersection = set.intersection(and, or.values[0]);
			var bIntersection = set.intersection(and, or.values[1]);
			if (!isOr(aIntersection) && !isOr(bIntersection)) {
				return set.union(aIntersection, bIntersection);
			}
			return new is.And([and, or]);
		}
1041361
def p_expr_AND_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'AND', p[1], p[3], lambda x, y: x and y)
301567
function all(array, pred) {
  for (let idx = 0, len = array.length; idx < len; idx++) {
    if (!pred(array[idx])) {
      return false;
    }
  }
  return true;
}
473234
def all(pred: Callable, xs: Iterable):
    
    for x in xs:
        if not pred(x):
            return False

    return True
255589
function(or, and) {
			var aDiff = set.difference(or, and.values[0]);
			var bDiff = set.difference(or, and.values[1]);
			return set.union(aDiff, bDiff);
		}
949484
public BooleanFormula andWith(BooleanFormula other) {
		if (other.isTrue()) {
			return this;
		}
		if (other.isFalse() || isFalse()) {
			if (booleanTerms == null) {
				booleanTerms = new HashSet<BooleanTerm>();
			} else {
				booleanTerms.clear();
			}
			isSimplified = true;
			return this;
		}
		if (isTrue()) {
			booleanTerms = new HashSet<BooleanTerm>(other.booleanTerms);
			return this;
		}
		BooleanFormula newTerms = new BooleanFormula();
		for (BooleanTerm otherTerm : other) {
			for (BooleanTerm term : booleanTerms) {
				BooleanTerm newTerm = term.andWith(otherTerm);
				if (newTerm != null) {
					newTerms.add(newTerm);
				}
			}
		}
		booleanTerms = newTerms.booleanTerms;
		isSimplified = newTerms.isSimplified;
		return this;
	}