Creates a list of a left and right list.

@param left  The left list.
@param right The right list.
@param <S>   The type of the list's elements.
@return A compound list representing the elements of both lists.
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;
    }
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);
        }
    }
366923
public static <L, R> Either<L, R> createLeft(L l) {
		return new Left<>(l);
	}
1216232
public static SMARTSAtom and(IQueryAtom left, IQueryAtom right) {
        return new Conjunction(left.getBuilder(), left, right);
    }
525299
def merge(left, right):
    
    merged = {}

    left_keys = frozenset(left)
    right_keys = frozenset(right)

    # Items only in the left Mapping
    for key in left_keys - right_keys:
        merged[key] = left[key]

    # Items only in the right Mapping
    for key in right_keys - left_keys:
        merged[key] = right[key]

    # in both
    for key in left_keys & right_keys:
        left_value = left[key]
        right_value = right[key]

        if (isinstance(left_value, Mapping) and
                isinstance(right_value, Mapping)):  # recursive merge
            merged[key] = merge(left_value, right_value)
        else:  # overwrite with right value
            merged[key] = right_value

    return merged
673465
public static Expression firstNonNull(final Expression left, final Expression right) {
    checkArgument(left.resultType().getSort() == Type.OBJECT);
    checkArgument(right.resultType().getSort() == Type.OBJECT);
    Features features = Features.of();
    if (Expression.areAllCheap(left, right)) {
      features = features.plus(Feature.CHEAP);
    }
    if (right.isNonNullable()) {
      features = features.plus(Feature.NON_NULLABLE);
    }
    return new Expression(left.resultType(), features) {
      @Override
      protected void doGen(CodeBuilder cb) {
        Label leftIsNonNull = new Label();
        left.gen(cb); // Stack: L
        cb.dup(); // Stack: L, L
        cb.ifNonNull(leftIsNonNull); // Stack: L
        // pop the extra copy of left
        cb.pop(); // Stack:
        right.gen(cb); // Stack: R
        cb.mark(leftIsNonNull); // At this point the stack has an instance of L or R
      }
    };
  }
942890
public static Boolean and(Boolean left, Boolean right) {
        return left && Boolean.TRUE.equals(right);
    }
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));
        }
    }
267619
public static IsLessThan isLessThan(ComparableExpression<Number> left, ComparableExpression<Number> right) {
        return new IsLessThan(left, right);
    }
1257814
public void add(int left, IntBitSet right) {
        if (line[left] == null) {
            line[left] = new IntBitSet();
        }
        line[left].addAll(right);
    }
1250447
public static <T> boolean listEquals(List<T> left, List<T> right) {
        if (left == null) {
            return right == null;
        } else {
            if (right == null) {
                return false;
            }
            if (left.size() != right.size()) {
                return false;
            }

            List<T> ltmp = new ArrayList<T>(left);
            List<T> rtmp = new ArrayList<T>(right);
            for (T t : ltmp) {
                rtmp.remove(t);
            }
            return rtmp.isEmpty();
        }
    }
1058759
private void insertionSort(int left, int right) {
        for (int p = left + 1; p <= right; p++) {
            byte[] tmpRange = ranges[p];
            String tmpFilename = filenames[p];

            int j;
            for (j = p; j > left && KeyUtils.compareKey(tmpRange, ranges[j - 1]) < 0; j--) {
                ranges[j] = ranges[j - 1];
                filenames[j] = filenames[j - 1];
            }
            ranges[j] = tmpRange;
            filenames[j] = tmpFilename;
        }
    }
547905
public static CharSequence concat(CharSequence left, CharSequence right) {
	if (left instanceof Appendable) {
	    try {
		((Appendable) left).append(right);
		return left;
	    }
	    catch (IOException e) {}
	}
	return new StringBuilder(left).append(right);
    }
777971
public static List<Address> leftMembers(View one, View two) {
        if(one == null || two == null)
            return null;
        List<Address> retval=new ArrayList<>(one.getMembers());
        retval.removeAll(two.getMembers());
        return retval;
    }
382625
public static <T> ImmutableSet<T> differenceAsSets(Iterable<T> left, Iterable<T> right) {
    return Sets.difference(ImmutableSet.copyOf(left), ImmutableSet.copyOf(right)).immutableCopy();
  }
520082
function merge(left, right, comparison) {
        var result = [],
            next = 0,
            sComp;

        result.length = left.length + right.length;
        while (left.length && right.length) {
            sComp = sortCompare(left, right);
            if (typeof sComp !== 'number') {
                if (comparison(left[0], right[0]) <= 0) {
                    if ($hasOwn(left, 0)) {
                        result[next] = left[0];
                    }

                    pShift.call(left);
                } else {
                    if ($hasOwn(right, 0)) {
                        result[next] = right[0];
                    }

                    pShift.call(right);
                }
            } else if (sComp <= 0) {
                if ($hasOwn(left, 0)) {
                    result[next] = left[0];
                }

                pShift.call(left);
            } else {
                if ($hasOwn(right, 0)) {
                    result[next] = right[0];
                }

                pShift.call(right);
            }

            next += 1;
        }

        while (left.length) {
            if ($hasOwn(left, 0)) {
                result[next] = left[0];
            }

            pShift.call(left);
            next += 1;
        }

        while (right.length) {
            if ($hasOwn(right, 0)) {
                result[next] = right[0];
            }

            pShift.call(right);
            next += 1;
        }

        return result;
    }
818104
public static <L, R> Tuple<L, R> newTuple (L left, R right)
    {
        return new Tuple<L, R>(left, right);
    }