Concat to the end of this array

@param Traversable,...
@return static
543954
public function concat()
    {
        $args = func_get_args();
        array_unshift($args, $this->sfa);

        // Concat this iterator, and variadic args
        $class = new ReflectionClass('Qaribou\Iterator\ConcatIterator');
        $concatIt = $class->newInstanceArgs($args);

        // Create as new immutable's iterator
        return new static($concatIt);
    }
452047
public static <T> Iterator<T> concat(final Iterator<? extends T>... iterators) {
        return new ImmutableIterator<T>() {
            int current = 0;

            @Override
            public boolean hasNext() {
                advance();
                return current < iterators.length;
            }

            @Override
            public T next() {
                advance();
                try {
                    return iterators[current].next();
                } catch (ArrayIndexOutOfBoundsException e) {
                    throw new NoSuchElementException();
                }
            }

            private void advance() {
                while (current < iterators.length && !iterators[current].hasNext()) {
                    current++;
                }
            }
        };
    }
328240
public function concat()
    {
        $inputs = func_get_args();

        foreach ($inputs as $input) {
            if (is_array($input)) {
                $input = new Buffer($input);
            }
            if ($input instanceof Buffer) {
                $length = $input->length();

                for ($i = 0; $i < $length; $i++) {
                    $this->data[] = $input[$i];
                }
            } else {
                throw new InvalidArgumentException('Input must be array or Buffer when call concat.');
            }
        }
        return $this;
    }
1077912
function concat( arr ) {
	var i;
	for ( i = 1; i < arr.length; i++ ) {
		arr[ 0 ] = arr[ 0 ].concat( arr[ i ] );
	}
	return arr[ 0 ];
}
756165
private static String concat(final String... parts) {

		final StringBuilder buf = new StringBuilder();

		for (final String part : parts) {

			// handle nulls gracefully (ignore)
			if (part != null) {

				buf.append(part);
			}
		}

		return buf.toString();
	}
311643
public static <T> Iterator<T> concat(Iterator<? extends Iterator<? extends T>> iterators) {
        Preconditions.checkArgumentNotNull(iterators, "iterators");
        return new CombinedIterator<T>(iterators);
    }
410071
function ( positions ) {
            if ( $B.isArray(positions) && !$B.isEmpty(positions) ) {
                this._startValue = positions[0].min;
                this._endValue = positions[positions.length - 1].max;
                this._positions = positions.concat([]);
            }
            return this;
        }
538273
public static <T, V extends T> Iterable<T> append(Iterable<T> iterable, V item) {
    return Iterables.concat(iterable, ImmutableList.<T>of(item));
  }
523145
private function traversable($traversable): \Iterator
    {
        if ($traversable instanceof \IteratorAggregate) {
            return $this->traversable($traversable->getIterator());
        }

        return $traversable;
    }
242147
public final <T3, T4> Tuple4<T1, T2, T3, T4> concat(Tuple2<T3, T4> tuple) {
        return new Tuple4<>(v1, v2, tuple.v1, tuple.v2);
    }
1328136
@NonNull
  public static <E> ImmutableSet<E> concatSet(
      @NonNull ImmutableSet<E> set, @NonNull Iterable<E> toConcat) {
    return ImmutableSet.<E>builder().addAll(set).addAll(toConcat).build();
  }
265008
public static function merge()
	{
		$result = array();
		$args = func_get_args();
		foreach ($args as &$array) {
			if ($array instanceof \Traversable) {
				foreach ($array as $key => $value) {
					$result[$key] = $value;
				}
			}
		}
		return $result;
	}
963198
public static <T> T[] concatAll(final T[] empty, Iterable<T[]> arrayList) {
        assert(empty.length == 0);
        if (arrayList.iterator().hasNext() == false) {
            return empty;
        }

        int len = 0;
        for (T[] subArray : arrayList) {
            len += subArray.length;
        }
        int pos = 0;
        T[] result = Arrays.copyOf(empty, len);
        for (T[] subArray : arrayList) {
            System.arraycopy(subArray, 0, result, pos, subArray.length);
            pos += subArray.length;
        }
        return result;
    }
420845
public static <T> T[] concat(T firstElement, T... array) {
		@SuppressWarnings("unchecked")
		T[] result = (T[]) Array.newInstance( firstElement.getClass(), 1 + array.length );
		result[0] = firstElement;
		System.arraycopy( array, 0, result, 1, array.length );

		return result;
	}
226257
public static <T extends Object> T[] concatenate (T[] v1, T[] v2)
    {
        @SuppressWarnings("unchecked")
        T[] values = (T[])Array.newInstance(v1.getClass().getComponentType(),
            v1.length + v2.length);
        System.arraycopy(v1, 0, values, 0, v1.length);
        System.arraycopy(v2, 0, values, v1.length, v2.length);
        return values;
    }
772970
public function append($other): self
    {
        if (is_array($this->elements) && !is_array($other) && !($other instanceof \Traversable)) {
            $all = $this->elements;
            $all[] = $other;
            return new self($all);
        }

        $appendIterator = new \AppendIterator();
        $appendIterator->append($this->getIterator());
        $appendIterator->append(castToIterator($other));
        return new self($appendIterator, $this->type);
    }
986311
private static String concat(final String... aPathsVarargs) {
        final String path;

        Objects.requireNonNull(aPathsVarargs);

        if (aPathsVarargs.length == 0) {
            path = "";
        } else {
            final StringBuffer pathBuf = new StringBuffer();

            Character lastChar = null;

            for (final String aPathsVararg : aPathsVarargs) {
                if (aPathsVararg != null) {
                    final int length;

                    if (lastChar != null && !mySeparator.equals(lastChar)) {
                        pathBuf.append(mySeparator);
                    }

                    pathBuf.append(aPathsVararg);
                    length = aPathsVararg.length();
                    lastChar = aPathsVararg.charAt(length - 1);
                }
            }

            path = pathBuf.toString();
        }

        return path;
    }