/* (non-Javadoc)
@see com.oath.cyclops.types.MonadicValue#concatMap(java.util.function.Function)
429752
@Override
    public <R> Future<R> concatMap(final Function<? super T, ? extends Iterable<? extends R>> mapper) {
        return (Future<R>) MonadicValue.super.concatMap(mapper);
    }
191344
public static <T> LazyIterable<T> concatenate(Iterable<T>... iterables)
    {
        return CompositeIterable.with(iterables);
    }
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++;
                }
            }
        };
    }
1069648
private static <T> ImmutableList<T> concatImmutableLists(
      ImmutableList<T> first, ImmutableList<T> second) {
    if (first.isEmpty()) {
      return second;
    }
    if (second.isEmpty()) {
      return first;
    }

    return ImmutableList.<T>builder().addAll(first).addAll(second).build();
  }
11333
def concat(self, enumerable):
        
        if not isinstance(enumerable, Enumerable):
            raise TypeError(
                u"enumerable argument must be an instance of Enumerable"
            )
        return Enumerable(itertools.chain(self._data, enumerable.data))
1000188
private static void concat(double[] target, double[] first, int firstLength, double[] second, int secondLength)
    {
        System.arraycopy(first, 0, target, 0, firstLength);
        System.arraycopy(second, 0, target, firstLength, secondLength);
    }
984798
function concat (target, data) {
    target = target || []
    if(Object.prototype.toString.call(data)!=='[object Array]') {
        data = [data]
    }
    Array.prototype.push.apply(target, data)
    return target
  }
304824
private <T extends ValueMap> T coerceToValueMap(Object object, Class<T> clazz) {
    if (object == null) return null;
    if (clazz.isAssignableFrom(object.getClass())) {
      //noinspection unchecked
      return (T) object;
    }
    if (object instanceof Map) return createValueMap((Map) object, clazz);
    return null;
  }
995953
public static <K, V, V2> MutableMap<K, V2> collectValues(
            Map<K, V> map,
            Function2<? super K, ? super V, ? extends V2> function)
    {
        return MapIterate.collectValues(map, function, UnifiedMap.<K, V2>newMap(map.size()));
    }
668331
public static <K,V> MultiValueMap<K,V> unmodifiableMultiValueMap(MultiValueMap<? extends K, ? extends V> map) {
		Assert.notNull(map, "'map' must not be null");
		Map<K, List<V>> result = new LinkedHashMap<K, List<V>>(map.size());
		for (Map.Entry<? extends K, ? extends List<? extends V>> entry : map.entrySet()) {
			List<V> values = Collections.unmodifiableList(entry.getValue());
			result.put(entry.getKey(), values);
		}
		Map<K, List<V>> unmodifiableMap = Collections.unmodifiableMap(result);
		return toMultiValueMap(unmodifiableMap);
	}
974325
public final <T5> Tuple5<T1, T2, T3, T4, T5> concat(T5 value) {
        return new Tuple5<>(v1, v2, v3, v4, value);
    }
848167
private static DecoratorMap concat(DecoratorMap... d_maps) {
        return (Stream<Consumer<MutableContext>> in, Context ctx) -> {
            for (DecoratorMap d_map : d_maps) {
                in = d_map.map(in, ctx);
            }
            return in;
        };
    }
702965
function concat() {
  const args = Array.from(arguments).filter(e => e != null);
  const baseArray = Array.isArray(args[0]) ? args[0] : [args[0]];
  return Array.prototype.concat.apply(baseArray, args.slice(1));
}
608502
function concatenation() {
    var ret = this.seq(
        repetition,
        this.manyf(this.seqf(
            this.many1f(c_wsp),
            repetition)));
    if (ret[2].length === 0) {
        return ret[1];
    }
    var cats = ret[2].map(function(el){ return el[2]; });
    return [].concat(ret[1]).concat(cats);
}
176004
public final <T2> Tuple2<T1, T2> concat(T2 value) {
        return new Tuple2<>(v1, value);
    }
188472
public static <T> Iterable<T> concat( final Iterable<T> a,
                                          final Iterable<T> b ) {
        assert (a != null);
        assert (b != null);
        return () -> Collections.concat(a.iterator(), b.iterator());

    }
417225
function mconcatMap(m, f, xs) {
  if(!isMonoid(m)) {
    throw new TypeError(
      'mconcatMap: Monoid required for first argument'
    )
  }

  if(!isFunction(f)) {
    throw new TypeError(
      'mconcatMap: Function required for second argument'
    )
  }

  if(!isFoldable(xs)) {
    throw new TypeError(
      'mconcatMap: Foldable required for third argument'
    )
  }

  return _mconcatMap(m, f, xs)
}