Creates an Add expression from the given expressions.

@param left  The left expression.
@param right The right expression.
@return An Add expression.
542862
public static Add add(Expression<Number> left, Expression<Number> right) {
        return new Add(left, right);
    }
566383
public static Object add(Object left, Object right) {
        return InfixOpNode.add(left, right, null);
    }
1173442
public static <D> Predicate notIn(Expression<D> left, Collection<? extends D> right) {
        if (right.size() == 1) {
            return neConst(left, right.iterator().next());
        } else {
            return predicate(Ops.NOT_IN, left, ConstantImpl.create(right));
        }
    }
460544
public AsymmMultiPos<S, String, String> betn(String left, String right) {
		return new AsymmMultiPos<S, String, String>(left, right) {

			@Override protected S result() {
				if (Strs.isEmpty(asymmLR)) {
					return aQueue('S', left, right, pos, position, inclusive, plusminus, filltgt);
				} else { return aQueue('Z', left, right, pos, asymmLR, inclusive, plusminus, filltgt); }
			}
		};
	}
660140
async def add(ctx, left: int, right: int):
    """"""
    await ctx.send(left + right)
838768
public static <S, T> Either<S, T> left(S left) {
    return new Left<>(left);
  }
57591
public void composeRightLeft(IntBitRelation left, IntBitRelation right) {
        int i, ele;
        IntBitSet li;

        for (i = 0; i < left.line.length; i++) {
            li = left.line[i];
            if (li != null) {
                for (ele = li.first(); ele != -1; ele = li.next(ele)) {
                    if (right.line[ele] != null) {
                        add(i, right.line[ele]);
                    }
                }
            }
        }
    }
694041
public static MaybeAssignedSet join(MaybeAssignedSet left, MaybeAssignedSet right) {
		if (left == null && right == null) {
			return null;
		} else if (left == null) {
			return right;
		} else if (right == null) {
			return left;
		} else {
			return left.join(right);
		}
	}
1362669
@NonNull
    public Expression add(@NonNull Expression expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression cannot be null.");
        }
        return new BinaryExpression(this, expression, BinaryExpression.OpType.Add);
    }
361078
public static AbstractExpression buildEquavalenceExpression(Collection<AbstractExpression> leftExprs, Collection<AbstractExpression> rightExprs) {
        assert(leftExprs.size() == rightExprs.size());
        Iterator<AbstractExpression> leftIt = leftExprs.iterator();
        Iterator<AbstractExpression> rightIt = rightExprs.iterator();
        AbstractExpression result = null;
        while (leftIt.hasNext() && rightIt.hasNext()) {
            AbstractExpression leftExpr = leftIt.next();
            AbstractExpression rightExpr = rightIt.next();
            AbstractExpression eqaulityExpr = new ComparisonExpression(ExpressionType.COMPARE_EQUAL, leftExpr, rightExpr);
            if (result == null) {
                result = eqaulityExpr;
            } else {
                result = new ConjunctionExpression(ExpressionType.CONJUNCTION_AND, result, eqaulityExpr);
            }
        }
        return result;
    }
190961
public static <S> List<S> of(List<? extends S> left, List<? extends S> right) {
        List<S> list = new ArrayList<S>(left.size() + right.size());
        list.addAll(left);
        list.addAll(right);
        return list;
    }
549268
public static <A extends Number & Comparable<?>> NumberExpression<A> min(Expression<A> left, Expression<A> right) {
        return NumberExpression.min(left, right);
    }
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);
        }
    }
991723
public static Number and(Number left, Number right) {
        return NumberMath.and(left, right);
    }
634128
public static Object sub(Object left, Object right) {
        return InfixOpNode.sub(left, right, null);
    }
99372
public static Expression compare(
      final int comparisonOpcode, final Expression left, final Expression right) {
    checkArgument(
        left.resultType().equals(right.resultType()),
        "left and right must have matching types, found %s and %s",
        left.resultType(),
        right.resultType());
    checkIntComparisonOpcode(left.resultType(), comparisonOpcode);
    Features features =
        Expression.areAllCheap(left, right) ? Features.of(Feature.CHEAP) : Features.of();
    return new Expression(Type.BOOLEAN_TYPE, features) {
      @Override
      protected void doGen(CodeBuilder mv) {
        left.gen(mv);
        right.gen(mv);
        Label ifTrue = mv.newLabel();
        Label end = mv.newLabel();
        mv.ifCmp(left.resultType(), comparisonOpcode, ifTrue);
        mv.pushBoolean(false);
        mv.goTo(end);
        mv.mark(ifTrue);
        mv.pushBoolean(true);
        mv.mark(end);
      }
    };
  }
415568
public function onArithmeticExpression($expressionType, $left, $right)
    {
        $type = $this->unpackExpressionType($expressionType);
        switch ($type) {
            case ExpressionType::MULTIPLY:
                return $this->prepareBinaryExpression(self::MULTIPLY, $left, $right);
            case ExpressionType::DIVIDE:
                return $this->prepareBinaryExpression(self::DIVIDE, $left, $right);
            case ExpressionType::MODULO:
                return $this->prepareBinaryExpression(self::MODULO, $left, $right);
            case ExpressionType::ADD:
                return $this->prepareBinaryExpression(self::ADD, $left, $right);
            case ExpressionType::SUBTRACT:
                return $this->prepareBinaryExpression(self::SUBTRACT, $left, $right);
            default:
                throw new \InvalidArgumentException('onArithmeticExpression');
        }
    }