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

  return x =>
    !!(predOrFunc(f, x) || predOrFunc(g, x))
}
286725
def _or(ctx, *logical):
    
    for arg in logical:
        if conversions.to_boolean(arg, ctx):
            return True
    return False
410757
public static Predicate or(Predicate left, Predicate right) {
        left = (Predicate) extract(left);
        right = (Predicate) extract(right);
        if (left == null) {
            return right;
        } else if (right == null) {
            return left;
        } else {
            return predicate(Ops.OR, left, right);
        }
    }
411190
@Pure
	@Inline(value="($1 && $2)", constantExpression=true)
	public static boolean operator_and(boolean a, boolean b) {
		return a && b;
	}
725969
function _bool(val) {
    if (arguments.length === 1) {
      this._boolFlag = val;
      return this;
    }
    var ret = this._boolFlag;
    this._boolFlag = 'and';
    return ret;
  }
513801
function and() {
    var predicates = Array.prototype.slice.call(arguments, 0);
    if (!predicates.length) {
      throw new Error('empty list of arguments to or');
    }

    return function orCheck() {
      var values = Array.prototype.slice.call(arguments, 0);
      return predicates.every(function (predicate) {
        return check.fn(predicate) ?
          predicate.apply(null, values) : Boolean(predicate);
      });
    };
  }
1021234
def visit_AST_or(self, pattern):
        
        return any(self.field_match(self.node, value_or)
                   for value_or in pattern.args)
283968
def __or(funcs, args):
    
    results = []
    for f in funcs:
        result = f(args)
        if result:
            results.extend(result)
    return results
1146445
public static function _or(/* ... */) {
        $args = func_get_args();
        return function ($features) use ($args) {
            $acc = false;
            foreach ($args as $arg)
                $acc = $acc || $arg($features);
            return $acc;
        };
    }
915229
def logical_and(self, other):
        """"""
        return self.operation(other, lambda x, y: int(x and y))
1110986
function(and, or) {
			var aUnion = set.union(and.values[0], or);
			var bUnion = set.union(and.values[1], or);

			if (!isAndOrOr(aUnion) || !isAndOrOr(bUnion)) {
				return set.intersection(aUnion, bUnion);
			}

			return new is.Or([and, or]);
		}
1150963
protected AstNode or(boolean required) throws ScanException, ParseException {
		AstNode v = and(required);
		if (v == null) {
			return null;
		}
		while (true) {
			switch (token.getSymbol()) {
				case OR:
					consumeToken();
					v = createAstBinary(v, and(true), AstBinary.OR);
					break;
				case EXTENSION:
					if (getExtensionHandler(token).getExtensionPoint() == ExtensionPoint.OR) {
						v = getExtensionHandler(consumeToken()).createAstNode(v, and(true));
						break;
					}
				default:
					return v;
			}
		}
	}
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);
		}
113872
function(elementA, elementB) {

        var isPredecessor = false;
        this.search(elementA, function(element) {
            if (element === elementB && element !== elementA) {
                isPredecessor = true;
                return false;
            }
        }, { inbound: true });
        return isPredecessor;
    }
471576
function any(predicate) {
  predicate = typeof predicate === 'function' ? predicate : util.defaultPredicate;

  for (let item of this) {
    if (predicate(item)) return true;
  }

  return false;
}
587580
def match?
      predicate.is_a?(Predicated::Equal) &&
              predicate.left.is_a?(String) &&
              predicate.right.is_a?(String)
    end
1084052
function or(arr1, arr2) {
                var ans = new Array(arr1.length);
                for (var i = 0; i < arr1.length; i++)
                    ans[i] = arr1[i] | arr2[i];
                return ans;
            }