logical_or(t) = self(t) or other(t).
977527
def logical_or(self, other):
        """"""
        return self.operation(other, lambda x, y: int(x or y))
193226
def logical_or(f1, f2):  # function factory
    '''
    '''
    def f(value):
        return np.logical_or(f1(value), f2(value))
    f.__name__ = "(" + f1.__name__ + "_or_" + f2.__name__ + ")"
    return f
997118
def assignment(self):
        
        node = self.logical_or_expr()
        if self.token.nature == Nature.ASSIGN:
            token = self.token
            self._process(Nature.ASSIGN)
            right = self.logical_or_expr()
            return Assignment(left=node, op=token, right=right)
        else:
            return node
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))
}
439145
def binary_operation_logical(self, rule, left, right, **kwargs):
        
        return LogicalBinOpRule(rule.operation, left, right)
770883
def is_entailed_by(self, other):
        
        other = BoolCell.coerce(other)
        if self.value == U or other.value == self.value:
            return True
        return False
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;
	}
861496
function processLogicalOr(tokenizer, scope) {
  let node = processLogicalAnd(tokenizer, scope);

  while (tokenizer.token.match(types.LOGICAL_OR)) {
    node = createOperatorNode(tokenizer.token.value, [node, processLogicalAnd(tokenizer.skipToken(), scope)]);
  }

  return node;
}
698493
def _le_from_lt(self, other):
    """"""
    op_result = self.__lt__(other)
    return op_result or self == other
14820
Expr ternary() {
		Expr cond = or();
		if (peek().sym == Sym.QUESTION) {
			move();
			Expr exprOne = expr();
			match(Sym.COLON);
			return new Ternary(cond, exprOne, expr(), location);
		}
		return cond;
	}
632151
public static Boolean or(Object left, Object right) {
        return (Boolean) InfixOpNode.or(left, right, null);
    }
718931
public static <S, D> Condition<S, D> or(Condition<S, D> condition1, Condition<S, D> condition2) {
    Assert.notNull(condition1, "condition1");
    Assert.notNull(condition2, "condition2");
    return new OrCondition<S, D>(condition1, condition2);
  }
1144007
def _and(ctx, *logical):
    
    for arg in logical:
        if not conversions.to_boolean(arg, ctx):
            return False
    return True
1129229
def evaluate_binop_logical(self, operation, left, right, **kwargs):
        
        if not operation in self.binops_logical:
            raise ValueError("Invalid logical binary operation '{}'".format(operation))
        result = self.binops_logical[operation](left, right)
        return bool(result)
696139
def _eq(self, other):
        """"""
        return (self.type, self.value) == (other.type, other.value)
578146
def p_conditional_expr(self, p):
        
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = self.asttypes.Conditional(
                predicate=p[1], consequent=p[3], alternative=p[5])
            p[0].setpos(p, 2)
1046247
def OR(self):
        
        clone = copy.deepcopy(self)
        clone.adapter._QUERY_GLUE = ' OR '
        return clone