All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.github.underscore.U Maven / Gradle / Ivy

    The newest version!
    /*
 * The MIT License (MIT)
 *
 * Copyright 2015-2019 Valentyn Kolesnikov
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package com.github.underscore;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;

/**
 * Underscore-java8 is a java 8 port of Underscore.js.
 *
 * @author Valentyn Kolesnikov
 */
public class U {
    private static final Map> FUNCTIONS = newLinkedHashMap();
    private static final Map TEMPLATE_SETTINGS = new HashMap();
    private static final int MIN_PASSWORD_LENGTH_8 = 8;
    private static final long CAPACITY_SIZE_5 = 5L;
    private static final long CAPACITY_COEFF_2 = 2L;
    private static final long CAPACITY_SIZE_16 = 16L;
    private static final java.util.concurrent.atomic.AtomicInteger UNIQUE_ID =
        new java.util.concurrent.atomic.AtomicInteger(0);
    private static final String ALL_SYMBOLS = "([\\s\\S]+?)";
    private static final String EVALUATE = "evaluate";
    private static final String INTERPOLATE = "interpolate";
    private static final String ESCAPE = "escape";
    private static final String S_Q = "\\s*\\Q";
    private static final String E_S = "\\E\\s*";
    private static final java.util.regex.Pattern FORMAT_PATTERN =
        java.util.regex.Pattern.compile("\\{\\s*(\\d*)\\s*\\}");
    private static final Map ESCAPES = new HashMap();
    private final Iterable iterable;
    private final Optional string;

    static {
        TEMPLATE_SETTINGS.put(EVALUATE, "<%([\\s\\S]+?)%>");
        TEMPLATE_SETTINGS.put(INTERPOLATE, "<%=([\\s\\S]+?)%>");
        TEMPLATE_SETTINGS.put(ESCAPE, "<%-([\\s\\S]+?)%>");
        ESCAPES.put('&', "&");
        ESCAPES.put('<', "<");
        ESCAPES.put('>', ">");
        ESCAPES.put('"', """);
        ESCAPES.put('\'', "'");
        ESCAPES.put('`', "`");
    }

    public U(final Iterable iterable) {
        this.iterable = iterable;
        this.string = Optional.absent();
    }

    public U(final String string) {
        this.iterable = null;
        this.string = Optional.of(string);
    }

    private static void setTemplateKey(final Map templateSettings, final String key) {
        if (templateSettings.containsKey(key) && templateSettings.get(key).contains(ALL_SYMBOLS)) {
            TEMPLATE_SETTINGS.put(key, templateSettings.get(key));
        }
    }

    public static void templateSettings(final Map templateSettings) {
        setTemplateKey(templateSettings, EVALUATE);
        setTemplateKey(templateSettings, INTERPOLATE);
        setTemplateKey(templateSettings, ESCAPE);
    }

    private static final class WherePredicate implements Predicate {
        private final List> properties;

        private WherePredicate(List> properties) {
            this.properties = properties;
        }

        @Override
        public boolean test(final E elem) {
            for (Tuple prop : properties) {
                try {
                    if (!elem.getClass().getField(prop.fst()).get(elem).equals(prop.snd())) {
                        return false;
                    }
                } catch (Exception ex) {
                    try {
                        if (!elem.getClass().getMethod(prop.fst()).invoke(elem).equals(prop.snd())) {
                            return false;
                        }
                    } catch (Exception e) {
                    }
                }
            }
            return true;
        }
    }

    private static final class TemplateImpl implements Template> {
        private final String template;

        private TemplateImpl(String template) {
            this.template = template;
        }

        @Override
        public String apply(Map value) {
            final String evaluate = TEMPLATE_SETTINGS.get(EVALUATE);
            final String interpolate = TEMPLATE_SETTINGS.get(INTERPOLATE);
            final String escape = TEMPLATE_SETTINGS.get(ESCAPE);
            String result = template;
            for (final Map.Entry element : value.entrySet()) {
                final String value1 = String.valueOf(element.getValue()).replace("\\", "\\\\");
                result = java.util.regex.Pattern.compile(interpolate.replace(ALL_SYMBOLS,
                    S_Q + element.getKey()
                    + E_S)).matcher(result).replaceAll(value1);
                result = java.util.regex.Pattern.compile(escape.replace(ALL_SYMBOLS,
                    S_Q + element.getKey()
                    + E_S)).matcher(result).replaceAll(escape(value1));
                result = java.util.regex.Pattern.compile(evaluate.replace(ALL_SYMBOLS,
                    S_Q + element.getKey()
                    + E_S)).matcher(result).replaceAll(value1);
            }
            return result;
        }

        @Override
        public List check(Map value) {
            final String evaluate = TEMPLATE_SETTINGS.get(EVALUATE);
            final String interpolate = TEMPLATE_SETTINGS.get(INTERPOLATE);
            final String escape = TEMPLATE_SETTINGS.get(ESCAPE);
            String result = template;
            final List notFound = new ArrayList();
            final List valueKeys = new ArrayList();
            for (final Map.Entry element : value.entrySet()) {
                final String key = "" + element.getKey();
                java.util.regex.Matcher matcher = java.util.regex.Pattern.compile(interpolate.replace(ALL_SYMBOLS,
                    S_Q + key + E_S)).matcher(result);
                boolean isFound = matcher.find();
                result = matcher.replaceAll(String.valueOf(element.getValue()));
                matcher = java.util.regex.Pattern.compile(escape.replace(ALL_SYMBOLS,
                    S_Q + key + E_S)).matcher(result);
                isFound |= matcher.find();
                result = matcher.replaceAll(escape(String.valueOf(element.getValue())));
                matcher = java.util.regex.Pattern.compile(evaluate.replace(ALL_SYMBOLS,
                    S_Q + key + E_S)).matcher(result);
                isFound |= matcher.find();
                result = matcher.replaceAll(String.valueOf(element.getValue()));
                if (!isFound) {
                    notFound.add(key);
                }
                valueKeys.add(key);
            }
            final List templateVars = new ArrayList();
            java.util.regex.Matcher matcher = java.util.regex.Pattern.compile(interpolate).matcher(result);
            while (matcher.find()) {
                templateVars.add(matcher.group(1).trim());
            }
            result = matcher.replaceAll("");
            matcher = java.util.regex.Pattern.compile(escape).matcher(result);
            while (matcher.find()) {
                templateVars.add(matcher.group(1).trim());
            }
            result = matcher.replaceAll("");
            matcher = java.util.regex.Pattern.compile(evaluate).matcher(result);
            while (matcher.find()) {
                templateVars.add(matcher.group(1).trim());
            }
            notFound.addAll(difference(templateVars, valueKeys));
            return notFound;
        }
    }

    private static final class MyIterable implements Iterable {
        private final UnaryOperator unaryOperator;
        private boolean firstRun = true;
        private T value;

        MyIterable(final T seed, final UnaryOperator unaryOperator) {
            this.value = seed;
            this.unaryOperator = unaryOperator;
        }

        public Iterator iterator() {
            return new Iterator() {
                @Override
                public boolean hasNext() {
                    return true;
                }
                @Override
                public T next() {
                    if (firstRun) {
                        firstRun = false;
                    } else {
                        value = unaryOperator.apply(value);
                    }
                    return value;
                }
                @Override
                public void remove() {
                }
            };
        }
    }

    public static  Function, V> iteratee(final K key) {
        return new Function, V>() {
            public V apply(Map item) {
                return item.get(key);
            }
        };
    }

    /*
     * Documented, #each
     */
    public static  void each(final Iterable iterable, final Consumer func) {
        for (T element : iterable) {
            func.accept(element);
        }
    }

    public static  void eachIndexed(final Iterable iterable, final BiConsumer func) {
        int index = 0;
        for (T element : iterable) {
            func.accept(index, element);
            index += 1;
        }
    }

    public void each(final Consumer func) {
        each(iterable, func);
    }

    public static  void eachRight(final Iterable iterable, final Consumer func) {
        each(reverse(iterable), func);
    }

    public void eachRight(final Consumer func) {
        eachRight(iterable, func);
    }

    public static  void forEach(final Iterable iterable, final Consumer func) {
        each(iterable, func);
    }

    public static  void forEachIndexed(final Iterable iterable, final BiConsumer func) {
        eachIndexed(iterable, func);
    }

    public void forEach(final Consumer func) {
        each(iterable, func);
    }

    public void forEachIndexed(final BiConsumer func) {
        eachIndexed(iterable, func);
    }

    public static  void forEachRight(final Iterable iterable, final Consumer func) {
        eachRight(iterable, func);
    }

    public void forEachRight(final Consumer func) {
        eachRight(iterable, func);
    }

    /*
     * Documented, #map
     */
    public static  List map(final List list, final Function func) {
        final List transformed = newArrayListWithExpectedSize(list.size());
        for (E element : list) {
            transformed.add(func.apply(element));
        }
        return transformed;
    }

    public  List map(final Function func) {
        return map(newArrayList(iterable), func);
    }

    public static  List map(final int[] array, final Function func) {
        final List transformed = newArrayListWithExpectedSize(array.length);
        for (int element : array) {
            transformed.add(func.apply(element));
        }
        return transformed;
    }

    public static  Set map(final Set set, final Function func) {
        final Set transformed = newLinkedHashSetWithExpectedSize(set.size());
        for (E element : set) {
            transformed.add(func.apply(element));
        }
        return transformed;
    }

    public static  List mapIndexed(final List list, final BiFunction func) {
        final List transformed = newArrayListWithExpectedSize(list.size());
        int index = 0;
        for (E element : list) {
            transformed.add(func.apply(index, element));
            index += 1;
        }
        return transformed;
    }

    public static  List replace(final Iterable iter, final Predicate pred, final T value) {
        List list = newArrayList(iter);
        if (pred == null) {
            return list;
        }
        ListIterator itera = list.listIterator();
        while (itera.hasNext()) {
            if (pred.test(itera.next())) {
                itera.set(value);
            }
        }
        return list;
    }

    public List replace(final Predicate pred, final T value) {
        return replace(value(), pred, value);
    }

    public static  List replaceIndexed(final Iterable iter, final PredicateIndexed pred, final T value) {
        List list = newArrayList(iter);
        if (pred == null) {
            return list;
        }
        ListIterator itera = list.listIterator();
        int index = 0;
        while (itera.hasNext()) {
            if (pred.test(index, itera.next())) {
                itera.set(value);
            }
            index++;
        }
        return list;
    }

    public List replaceIndexed(final PredicateIndexed pred, final T value) {
        return replaceIndexed(value(), pred, value);
    }

    public  List mapIndexed(final BiFunction func) {
        return mapIndexed(newArrayList(iterable), func);
    }

    public static  List collect(final List list, final Function func) {
        return map(list, func);
    }

    public static  Set collect(final Set set, final Function func) {
        return map(set, func);
    }

    /*
     * Documented, #reduce
     */
    public static  E reduce(final Iterable iterable, final BiFunction func, final E zeroElem) {
        E accum = zeroElem;
        for (T element : iterable) {
            accum = func.apply(accum, element);
        }
        return accum;
    }

    public static  Optional reduce(final Iterable iterable, final BinaryOperator func) {
        boolean foundAny = false;
        T accum = null;
        for (T element : iterable) {
            if (foundAny) {
                accum = func.apply(accum, element);
            } else {
                foundAny = true;
                accum = element;
            }
        }
        return foundAny ? Optional.of(accum) : Optional.absent();
    }

    public static  E reduce(final int[] array, final BiFunction func, final E zeroElem) {
        E accum = zeroElem;
        for (int element : array) {
            accum = func.apply(accum, element);
        }
        return accum;
    }

    public static  E reduce(final T[] array, final BiFunction func, final E zeroElem) {
        E accum = zeroElem;
        for (T element : array) {
            accum = func.apply(accum, element);
        }
        return accum;
    }

    public static  E foldl(final Iterable iterable, final BiFunction func, final E zeroElem) {
        return reduce(iterable, func, zeroElem);
    }

    public static  E inject(final Iterable iterable, final BiFunction func, final E zeroElem) {
        return reduce(iterable, func, zeroElem);
    }

    /*
     * Documented, #reduceRight
     */
    public static  E reduceRight(final Iterable iterable, final BiFunction func, final E zeroElem) {
        return reduce(reverse(iterable), func, zeroElem);
    }

    public static  Optional reduceRight(final Iterable iterable, final BinaryOperator func) {
        return reduce(reverse(iterable), func);
    }

    public static  E reduceRight(final int[] array, final BiFunction func, final E zeroElem) {
        E accum = zeroElem;
        for (Integer element : reverse(array)) {
            accum = func.apply(accum, element);
        }
        return accum;
    }

    public static  E reduceRight(final T[] array, final BiFunction func, final E zeroElem) {
        return reduce(reverse(array), func, zeroElem);
    }

    public static  E foldr(final Iterable iterable, final BiFunction func, final E zeroElem) {
        return reduceRight(iterable, func, zeroElem);
    }

    /*
     * Documented, #find
     */
    public static  Optional find(final Iterable iterable, final Predicate pred) {
        for (E element : iterable) {
            if (pred.test(element)) {
                return Optional.of(element);
            }
        }
        return Optional.absent();
    }

    public static  Optional detect(final Iterable iterable, final Predicate pred) {
        return find(iterable, pred);
    }

    public static  Optional findLast(final Iterable iterable, final Predicate pred) {
        return find(reverse(iterable), pred);
    }

    /*
     * Documented, #filter
     */
    public static  List filter(final Iterable iterable, final Predicate pred) {
        final List filtered = newArrayList();
        for (E element : iterable) {
            if (pred.test(element)) {
                filtered.add(element);
            }
        }
        return filtered;
    }

    public static  List filter(final List list, final Predicate pred) {
        final List filtered = newArrayList();
        for (E element : list) {
            if (pred.test(element)) {
                filtered.add(element);
            }
        }
        return filtered;
    }

    public List filter(final Predicate pred) {
        final List filtered = newArrayList();
        for (final T element : value()) {
            if (pred.test(element)) {
                filtered.add(element);
            }
        }
        return filtered;
    }

    public static  List filterIndexed(final List list, final PredicateIndexed pred) {
        final List filtered = newArrayList();
        int index = 0;
        for (E element : list) {
            if (pred.test(index, element)) {
                filtered.add(element);
            }
            index += 1;
        }
        return filtered;
    }

    public static  Set filter(final Set set, final Predicate pred) {
        final Set filtered = newLinkedHashSet();
        for (E element : set) {
            if (pred.test(element)) {
                filtered.add(element);
            }
        }
        return filtered;
    }

    public static  List select(final List list, final Predicate pred) {
        return filter(list, pred);
    }

    public static  Set select(final Set set, final Predicate pred) {
        return filter(set, pred);
    }

    /*
     * Documented, #reject
     */
    public static  List reject(final List list, final Predicate pred) {
        return filter(list, new Predicate() {
            @Override
            public boolean test(E input) {
                return !pred.test(input);
            }
        });
    }

    public List reject(final Predicate pred) {
        return filter(new Predicate() {
            @Override
            public boolean test(T input) {
                return !pred.test(input);
            }
        });
    }

    public static  List rejectIndexed(final List list, final PredicateIndexed pred) {
        return filterIndexed(list, new PredicateIndexed() {
            @Override
            public boolean test(int index, E input) {
                return !pred.test(index, input);
            }
        });
    }

    public static  Set reject(final Set set, final Predicate pred) {
        return filter(set, new Predicate() {
            @Override
            public boolean test(E input) {
                return !pred.test(input);
            }
        });
    }

    public static  List filterFalse(final List list, final Predicate pred) {
        return reject(list, pred);
    }

    public List filterFalse(final Predicate pred) {
        return reject(pred);
    }

    public static  Set filterFalse(final Set set, final Predicate pred) {
        return reject(set, pred);
    }

    public static  boolean every(final Iterable iterable, final Predicate pred) {
        for (E item : iterable) {
            if (!pred.test(item)) {
                return false;
            }
        }
        return true;
    }

    public boolean every(final Predicate pred) {
        return every(iterable, pred);
    }

    /*
     * Documented, #all
     */
    public static  boolean all(final Iterable iterable, final Predicate pred) {
        return every(iterable, pred);
    }

    public boolean all(final Predicate pred) {
        return every(iterable, pred);
    }

    public static  boolean some(final Iterable iterable, final Predicate pred) {
        return find(iterable, pred).isPresent();
    }

    public boolean some(final Predicate pred) {
        return some(iterable, pred);
    }

    /*
     * Documented, #any
     */
    public static  boolean any(final Iterable iterable, final Predicate pred) {
        return some(iterable, pred);
    }

    public boolean any(final Predicate pred) {
        return some(iterable, pred);
    }

    public static  int count(final Iterable iterable, final Predicate pred) {
        int result = 0;
        for (E item : iterable) {
            if (pred.test(item)) {
                result += 1;
            }
        }
        return result;
    }

    public int count(final Predicate pred) {
        return count(iterable, pred);
    }

    public static  boolean contains(final Iterable iterable, final E elem) {
        return some(iterable, new Predicate() {
            @Override
            public boolean test(E e) {
                return elem == null ? e == null : elem.equals(e);
            }
        });
    }

    public boolean contains(final T elem) {
        return contains(iterable, elem);
    }

    public static  boolean containsWith(final Iterable iterable, final E elem) {
        return some(iterable, new Predicate() {
            @Override
            public boolean test(E e) {
                return elem == null ? e == null : String.valueOf(e).contains(String.valueOf(elem));
            }
        });
    }

    public boolean containsWith(final T elem) {
        return containsWith(iterable, elem);
    }

    public static  boolean contains(final Iterable iterable, final E elem, final int fromIndex) {
        final List list = newArrayList(iterable);
        return contains(list.subList(fromIndex, list.size()), elem);
    }

    public boolean containsAtLeast(final T value, final int count) {
        return U.containsAtLeast(this.iterable, value, count);
    }

    public boolean containsAtMost(final T value, final int count) {
        return U.containsAtMost(this.iterable, value, count);
    }

    public static  boolean containsAtLeast(final Iterable iterable, final E value, final int count) {
        int foundItems = 0;
        for (E element : iterable) {
            if (element == null ? value == null : element.equals(value)) {
                foundItems += 1;
            }
            if (foundItems >= count) {
                break;
            }
        }
        return foundItems >= count;
    }

    public static  boolean containsAtMost(final Iterable iterable, final E value, final int count) {
        int foundItems = size(iterable);
        for (E element : iterable) {
            if (!(element == null ? value == null : element.equals(value))) {
                foundItems -= 1;
            }
            if (foundItems <= count) {
                break;
            }
        }
        return foundItems <= count;
    }

    /*
     * Documented, #include
     */
    public static  boolean include(final Iterable iterable, final E elem) {
        return contains(iterable, elem);
    }

    /*
     * Documented, #invoke
     */
    @SuppressWarnings("unchecked")
    public static  List invoke(final Iterable iterable, final String methodName,
                                  final List args) {
        final List result = newArrayList();
        final List> argTypes = map(args, new Function>() {
            public Class apply(Object input) {
                return input.getClass();
            }
        });
        try {
            final Method method = iterable.iterator().next().getClass().getMethod(methodName, argTypes.toArray(
                    new Class[0]));
            for (E arg : iterable) {
                try {
                    result.add((E) method.invoke(arg, args.toArray(new Object[0])));
                } catch (Exception e) {
                    throw new IllegalArgumentException(e);
                }
            }
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException(e);
        }
        return result;
    }

    public List invoke(final String methodName, final List args) {
        return invoke(iterable, methodName, args);
    }

    public static  List invoke(final Iterable iterable, final String methodName) {
        return invoke(iterable, methodName, Collections.emptyList());
    }

    public List invoke(final String methodName) {
        return invoke(iterable, methodName);
    }

    /*
     * Documented, #pluck
     */
    public static  List pluck(final List list, final String propertyName) {
        if (list.isEmpty()) {
            return Collections.emptyList();
        }
        return map(list, new Function() {
            @Override
            public Object apply(E elem) {
                try {
                    return elem.getClass().getField(propertyName).get(elem);
                } catch (Exception e) {
                    try {
                        return elem.getClass().getMethod(propertyName).invoke(elem);
                    } catch (Exception ex) {
                        throw new IllegalArgumentException(ex);
                    }
                }
            }
        });
    }

    public List pluck(final String propertyName) {
        return pluck(newArrayList(iterable), propertyName);
    }

    public static  Set pluck(final Set set, final String propertyName) {
        if (set.isEmpty()) {
            return Collections.emptySet();
        }
        return map(set, new Function() {
            @Override
            public Object apply(E elem) {
                try {
                    return elem.getClass().getField(propertyName).get(elem);
                } catch (Exception e) {
                    try {
                        return elem.getClass().getMethod(propertyName).invoke(elem);
                    } catch (Exception ex) {
                        throw new IllegalArgumentException(ex);
                    }
                }
            }
        });
    }

    /*
     * Documented, #where
     */
    public static  List where(final List list,
                                    final List> properties) {
        return filter(list, new WherePredicate(properties));

    }

    public  List where(final List> properties) {
        return where(newArrayList(iterable), properties);
    }

    public static  Set where(final Set set,
                                   final List> properties) {
        return filter(set, new WherePredicate(properties));
    }

    /*
     * Documented, #findWhere
     */
    public static  Optional findWhere(final Iterable iterable,
                                  final List> properties) {
        return find(iterable, new WherePredicate(properties));
    }

    public  Optional findWhere(final List> properties) {
        return findWhere(iterable, properties);
    }

    /*
     * Documented, #max
     */
    public static > E max(final Collection collection) {
        return Collections.max(collection);
    }

    @SuppressWarnings("unchecked")
    public T max() {
        return (T) max((Collection) iterable);
    }

    @SuppressWarnings("unchecked")
    public static  E max(final Collection collection, final Function func) {
        return Collections.max(collection, new Comparator() {
            @Override
            public int compare(E o1, E o2) {
                return func.apply(o1).compareTo(func.apply(o2));
            }
        });
    }

    @SuppressWarnings("unchecked")
    public > T max(final Function func) {
        return (T) max((Collection) iterable, func);
    }

    /*
     * Documented, #min
     */
    public static > E min(final Collection collection) {
        return Collections.min(collection);
    }

    @SuppressWarnings("unchecked")
    public T min() {
        return (T) min((Collection) iterable);
    }

    @SuppressWarnings("unchecked")
    public static  E min(final Collection collection, final Function func) {
        return Collections.min(collection, new Comparator() {
            @Override
            public int compare(E o1, E o2) {
                return func.apply(o1).compareTo(func.apply(o2));
            }
        });
    }

    @SuppressWarnings("unchecked")
    public > T min(final Function func) {
        return (T) min((Collection) iterable, func);
    }

    /*
     * Documented, #shuffle
     */
    public static  List shuffle(final Iterable iterable) {
        final List shuffled = newArrayList(iterable);
        Collections.shuffle(shuffled);
        return shuffled;
    }

    public List shuffle() {
        return shuffle(iterable);
    }

    /*
     * Documented, #sample
     */
    public static  E sample(final Iterable iterable) {
        return newArrayList(iterable).get(new java.security.SecureRandom().nextInt(size(iterable)));
    }

    public T sample() {
        return sample(iterable);
    }

    public static  Set sample(final List list, final int howMany) {
        final int size = Math.min(howMany, list.size());
        final Set samples = newLinkedHashSetWithExpectedSize(size);
        while (samples.size() < size) {
            E sample = sample(list);
            samples.add(sample);
        }
        return samples;
    }

    public static > List sortWith(final Iterable iterable,
        final Comparator comparator) {
        final List sortedList = newArrayList(iterable);
        Collections.sort(sortedList, comparator);
        return sortedList;
    }

    @SuppressWarnings("unchecked")
    public > List sortWith(final Comparator comparator) {
        return sortWith((Iterable) iterable, comparator);
    }

    /*
     * Documented, #sortBy
     */
    public static > List sortBy(final Iterable iterable,
        final Function func) {
        final List sortedList = newArrayList(iterable);
        Collections.sort(sortedList, new Comparator() {
            @Override
            public int compare(E o1, E o2) {
                return func.apply(o1).compareTo(func.apply(o2));
            }
        });
        return sortedList;
    }

    @SuppressWarnings("unchecked")
    public > List sortBy(final Function func) {
        return sortBy((Iterable) iterable, func);
    }

    public static > List> sortBy(final Iterable> iterable,
        final K key) {
        final List> sortedList = newArrayList(iterable);
        Collections.sort(sortedList, new Comparator>() {
            @Override
            public int compare(Map o1, Map o2) {
                return o1.get(key).compareTo(o2.get(key));
            }
        });
        return sortedList;
    }

    /*
     * Documented, #groupBy
     */
    public static  Map> groupBy(final Iterable iterable, final Function func) {
        final Map> retVal = newLinkedHashMap();
        for (E e : iterable) {
            final K key = func.apply(e);
            List val;
            if (retVal.containsKey(key)) {
                val = retVal.get(key);
            } else {
                val = newArrayList();
            }
            val.add(e);
            retVal.put(key, val);
        }
        return retVal;
    }

    @SuppressWarnings("unchecked")
    public  Map> groupBy(final Function func) {
        return groupBy((Iterable) iterable, func);
    }

    public static  Map> groupBy(final Iterable iterable, final Function func,
        final BinaryOperator binaryOperator) {
        final Map> retVal = newLinkedHashMap();
        for (Map.Entry> entry : groupBy(iterable, func).entrySet()) {
            retVal.put(entry.getKey(), reduce(entry.getValue(), binaryOperator));
        }
        return retVal;
    }

    @SuppressWarnings("unchecked")
    public  Map> groupBy(final Function func, final BinaryOperator binaryOperator) {
        return groupBy((Iterable) iterable, func, binaryOperator);
    }

    @SuppressWarnings("unchecked")
    public static  Map> indexBy(final Iterable iterable, final String property) {
        return groupBy(iterable, new Function() {
            @Override
            public K apply(E elem) {
                try {
                    return (K) elem.getClass().getField(property).get(elem);
                } catch (Exception e) {
                    return null;
                }
            }
        });
    }

    @SuppressWarnings("unchecked")
    public  Map> indexBy(final String property) {
        return indexBy((Iterable) iterable, property);
    }

    /*
     * Documented, #countBy
     */
    public static  Map countBy(final Iterable iterable, Function func) {
        final Map retVal = newLinkedHashMap();
        for (E e : iterable) {
            final K key = func.apply(e);
            if (retVal.containsKey(key)) {
                retVal.put(key, 1 + retVal.get(key));
            } else {
                retVal.put(key, 1);
            }
        }
        return retVal;
    }

    public static  Map countBy(final Iterable iterable) {
        final Map retVal = newLinkedHashMap();
        for (K key : iterable) {
            if (retVal.containsKey(key)) {
                retVal.put(key, 1 + retVal.get(key));
            } else {
                retVal.put(key, 1);
            }
        }
        return retVal;
    }

    @SuppressWarnings("unchecked")
    public  Map countBy(Function func) {
        return countBy((Iterable) iterable, func);
    }

    @SuppressWarnings("unchecked")
    public  Map countBy() {
        return countBy((Iterable) iterable);
    }

    /*
     * Documented, #toArray
     */
    @SuppressWarnings("unchecked")
    public static  E[] toArray(final Iterable iterable) {
        return (E[]) newArrayList(iterable).toArray();
    }

    @SuppressWarnings("unchecked")
    public  E[] toArray() {
        return toArray((Iterable) iterable);
    }

    /*
     * Documented, #toMap
     */
    public static  Map toMap(final Iterable> iterable) {
        final Map result = newLinkedHashMap();
        for (Map.Entry entry : iterable) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    public  Map toMap() {
        return toMap((Iterable>) iterable);
    }

    public static  Map toMap(final List> tuples) {
        final Map result = newLinkedHashMap();
        for (final Tuple entry : tuples) {
            result.put(entry.fst(), entry.snd());
        }
        return result;
    }

    public Map toCardinalityMap() {
        return toCardinalityMap(iterable);
    }

    public static  Map toCardinalityMap(final Iterable iterable) {
        Iterator iterator = iterable.iterator();
        Map result = newLinkedHashMap();

        while (iterator.hasNext()) {
            K item = iterator.next();

            if (result.containsKey(item)) {
                result.put(item, result.get(item) + 1);
            } else {
                result.put(item, 1);
            }
        }
        return result;
    }

    /*
     * Documented, #size
     */
    public static int size(final Iterable iterable) {
        if (iterable instanceof Collection) {
            return ((Collection) iterable).size();
        }
        int size;
        final Iterator iterator = iterable.iterator();
        for (size = 0; iterator.hasNext(); size += 1) {
            iterator.next();
        }
        return size;
    }

    public int size() {
        return size(iterable);
    }

    @SuppressWarnings("unchecked")
    public static  int size(final E ... array) {
        return array.length;
    }

    @SuppressWarnings("unchecked")
    public static  List> partition(final Iterable iterable, final Predicate pred) {
        final List retVal1 = newArrayList();
        final List retVal2 = newArrayList();
        for (final E e : iterable) {
            if (pred.test(e)) {
                retVal1.add(e);
            } else {
                retVal2.add(e);
            }
        }
        return Arrays.asList(retVal1, retVal2);
    }

    @SuppressWarnings("unchecked")
    public static  List[] partition(final E[] iterable, final Predicate pred) {
        return partition(Arrays.asList(iterable), pred).toArray(new ArrayList[0]);
    }

    public T singleOrNull() {
        return singleOrNull(iterable);
    }

    public T singleOrNull(Predicate pred) {
        return singleOrNull(iterable, pred);
    }

    public static  E singleOrNull(final Iterable iterable) {
        Iterator iterator = iterable.iterator();
        if (!iterator.hasNext()) {
            return null;
        }
        E result = iterator.next();

        if (iterator.hasNext()) {
            result = null;
        }
        return result;
    }

    public static  E singleOrNull(final Iterable iterable, Predicate pred) {
        return singleOrNull(filter(iterable, pred));
    }

    /*
     * Documented, #first
     */
    public static  E first(final Iterable iterable) {
        return iterable.iterator().next();
    }

    @SuppressWarnings("unchecked")
    public static  E first(final E ... array) {
        return array[0];
    }

    public static  List first(final List list, final int n) {
        return list.subList(0, Math.min(n < 0 ? 0 : n, list.size()));
    }

    public T first() {
        return first(iterable);
    }

    public List first(final int n) {
        return first(newArrayList(iterable), n);
    }

    public static  E first(final Iterable iterable, final Predicate pred) {
        return filter(newArrayList(iterable), pred).iterator().next();
    }

    public static  List first(final Iterable iterable, final Predicate pred, final int n) {
        List list = filter(newArrayList(iterable), pred);
        return list.subList(0, Math.min(n < 0 ? 0 : n, list.size()));
    }

    public T first(final Predicate pred) {
        return first(newArrayList(iterable), pred);
    }

    public List first(final Predicate pred, final int n) {
        return first(newArrayList(iterable), pred, n);
    }

    public static  E firstOrNull(final Iterable iterable) {
        final Iterator iterator = iterable.iterator();
        return iterator.hasNext() ? iterator.next() : null;
    }

    public T firstOrNull() {
        return firstOrNull(iterable);
    }

    public static  E firstOrNull(final Iterable iterable, final Predicate pred) {
        final Iterator iterator = filter(newArrayList(iterable), pred).iterator();
        return iterator.hasNext() ? iterator.next() : null;
    }

    public T firstOrNull(final Predicate pred) {
        return firstOrNull(iterable, pred);
    }

    public static  E head(final Iterable iterable) {
        return first(iterable);
    }

    @SuppressWarnings("unchecked")
    public static  E head(final E ... array) {
        return first(array);
    }

    public static  List head(final List list, final int n) {
        return first(list, n);
    }

    public T head() {
        return first();
    }

    public List head(final int n) {
        return first(n);
    }

    /*
     * Documented, #initial
     */
    public static  List initial(final List list) {
        return initial(list, 1);
    }

    public static  List initial(final List list, final int n) {
        return list.subList(0, Math.max(0, list.size() - n));
    }

    @SuppressWarnings("unchecked")
    public static  E[] initial(final E ... array) {
        return initial(array, 1);
    }

    public static  E[] initial(final E[] array, final int n) {
        return Arrays.copyOf(array, array.length - n);
    }

    public List initial() {
        return initial((List) iterable, 1);
    }

    public List initial(final int n) {
        return initial((List) iterable, n);
    }

    @SuppressWarnings("unchecked")
    public static  E last(final E ... array) {
        return array[array.length - 1];
    }

    /*
     * Documented, #last
     */
    public static  E last(final List list) {
        return list.get(list.size() - 1);
    }

    public static  List last(final List list, final int n) {
        return list.subList(Math.max(0, list.size() - n), list.size());
    }

    public T last() {
        return last((List) iterable);
    }

    public List last(final int n) {
        return last((List) iterable, n);
    }

    public static  E last(final List list, final Predicate pred) {
        final List filteredList = filter(list, pred);
        return filteredList.get(filteredList.size() - 1);
    }

    public T last(final Predicate pred) {
        return last((List) iterable, pred);
    }

    public static  E lastOrNull(final List list) {
        return list.isEmpty() ? null : list.get(list.size() - 1);
    }

    public T lastOrNull() {
        return lastOrNull((List) iterable);
    }

    public static  E lastOrNull(final List list, final Predicate pred) {
        final List filteredList = filter(list, pred);
        return filteredList.isEmpty() ? null : filteredList.get(filteredList.size() - 1);
    }

    public T lastOrNull(final Predicate pred) {
        return lastOrNull((List) iterable, pred);
    }

    /*
     * Documented, #rest
     */
    public static  List rest(final List list) {
        return rest(list, 1);
    }

    public static  List rest(final List list, int n) {
        return list.subList(Math.min(n, list.size()), list.size());
    }

    @SuppressWarnings("unchecked")
    public static  E[] rest(final E ... array) {
        return rest(array, 1);
    }

    @SuppressWarnings("unchecked")
    public static  E[] rest(final E[] array, final int n) {
        return (E[]) rest(Arrays.asList(array), n).toArray();
    }

    public List rest() {
        return rest((List) iterable);
    }

    public List rest(int n) {
        return rest((List) iterable, n);
    }

    public static  List tail(final List list) {
        return rest(list);
    }

    public static  List tail(final List list, final int n) {
        return rest(list, n);
    }

    @SuppressWarnings("unchecked")
    public static  E[] tail(final E ... array) {
        return rest(array);
    }

    public static  E[] tail(final E[] array, final int n) {
        return rest(array, n);
    }

    public List tail() {
        return rest();
    }

    public List tail(final int n) {
        return rest(n);
    }

    public static  List drop(final List list) {
        return rest(list);
    }

    public static  List drop(final List list, final int n) {
        return rest(list, n);
    }

    @SuppressWarnings("unchecked")
    public static  E[] drop(final E ... array) {
        return rest(array);
    }

    public static  E[] drop(final E[] array, final int n) {
        return rest(array, n);
    }

    /*
     * Documented, #compact
     */
    public static  List compact(final List list) {
        return filter(list, new Predicate() {
            @Override
            public boolean test(E arg) {
                return !String.valueOf(arg).equals("null") && !String.valueOf(arg).equals("0")
                    && !String.valueOf(arg).equals("false") && !String.valueOf(arg).equals("");
            }
        });
    }

    @SuppressWarnings("unchecked")
    public static  E[] compact(final E ... array) {
        return (E[]) compact(Arrays.asList(array)).toArray();
    }

    public static  List compact(final List list, final E falsyValue) {
        return filter(list, new Predicate() {
            @Override
            public boolean test(E arg) {
                return !(arg == null ? falsyValue == null : arg.equals(falsyValue));
            }
        });
    }

    @SuppressWarnings("unchecked")
    public static  E[] compact(final E[] array, final E falsyValue) {
        return (E[]) compact(Arrays.asList(array), falsyValue).toArray();
    }

    public List compact() {
        return compact((List) iterable);
    }

    public List compact(final T falsyValue) {
        return compact((List) iterable, falsyValue);
    }

    /*
     * Documented, #flatten
     */
    public static  List flatten(final List list) {
        List flattened = newArrayList();
        flatten(list, flattened, -1);
        return flattened;
    }

    public static  List flatten(final List list, final boolean shallow) {
        List flattened = newArrayList();
        flatten(list, flattened, shallow ? 1 : -1);
        return flattened;
    }

    @SuppressWarnings("unchecked")
    private static  void flatten(final List fromTreeList, final List toFlatList, final int shallowLevel) {
        for (Object item : fromTreeList) {
            if (item instanceof List && shallowLevel != 0) {
                flatten((List) item, toFlatList, shallowLevel - 1);
            } else {
                toFlatList.add((E) item);
            }
        }
    }

    public List flatten() {
        return flatten((List) iterable);
    }

    public List flatten(final boolean shallow) {
        return flatten((List) iterable, shallow);
    }

    /*
     * Documented, #without
     */
    @SuppressWarnings("unchecked")
    public static  List without(final List list, E ... values) {
        final List valuesList = Arrays.asList(values);
        return filter(list, new Predicate() {
            @Override
            public boolean test(E elem) {
                return !contains(valuesList, elem);
            }
        });
    }

    @SuppressWarnings("unchecked")
    public static  E[] without(final E[] array, final E ... values) {
        return (E[]) without(Arrays.asList(array), values).toArray();
    }

    /*
     * Documented, #uniq
     */
    public static  List uniq(final List list) {
        return newArrayList(newLinkedHashSet(list));
    }

    @SuppressWarnings("unchecked")
    public static  E[] uniq(final E ... array) {
        return (E[]) uniq(Arrays.asList(array)).toArray();
    }

    public static  Collection uniq(final Iterable iterable, final Function func) {
        final Map retVal = newLinkedHashMap();
        for (final E e : iterable) {
            final K key = func.apply(e);
            retVal.put(key, e);
        }
        return retVal.values();
    }

    @SuppressWarnings("unchecked")
    public static  E[] uniq(final E[] array, final Function func) {
        return (E[]) uniq(Arrays.asList(array), func).toArray();
    }

    public static  List distinct(final List list) {
        return uniq(list);
    }

    @SuppressWarnings("unchecked")
    public static  E[] distinct(final E ... array) {
        return uniq(array);
    }

    public static  Collection distinctBy(final Iterable iterable, final Function func) {
        return uniq(iterable, func);
    }

    public static  E[] distinctBy(final E[] array, final Function func) {
        return uniq(array, func);
    }

    /*
     * Documented, #union
     */
    @SuppressWarnings("unchecked")
    public static  List union(final List list, final List ... lists) {
        final Set union = newLinkedHashSet();
        union.addAll(list);
        for (List localList : lists) {
            union.addAll(localList);
        }
        return newArrayList(union);
    }

    @SuppressWarnings("unchecked")
    public List unionWith(final List ... lists) {
        return union(newArrayList(iterable), lists);
    }

    @SuppressWarnings("unchecked")
    public static  E[] union(final E[] ... arrays) {
        final Set union = newLinkedHashSet();
        for (E[] array : arrays) {
            union.addAll(Arrays.asList(array));
        }
        return (E[]) newArrayList(union).toArray();
    }

    /*
     * Documented, #intersection
     */
    public static  List intersection(final List list1, final List list2) {
        final List result = newArrayList();
        for (final E item : list1) {
            if (list2.contains(item)) {
                result.add(item);
            }
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    public static  List intersection(final List list, final List ... lists) {
        final Deque> stack = new ArrayDeque>();
        stack.push(list);
        for (List es : lists) {
            stack.push(intersection(stack.peek(), es));
        }
        return stack.peek();
    }

    @SuppressWarnings("unchecked")
    public List intersectionWith(final List ... lists) {
        return intersection(newArrayList(iterable), lists);
    }

    @SuppressWarnings("unchecked")
    public static  E[] intersection(final E[] ... arrays) {
        final Deque> stack = new ArrayDeque>();
        stack.push(Arrays.asList(arrays[0]));
        for (int index = 1; index < arrays.length; index += 1) {
            stack.push(intersection(stack.peek(), Arrays.asList(arrays[index])));
        }
        return (E[]) stack.peek().toArray();
    }

    /*
     * Documented, #difference
     */
    public static  List difference(final List list1, final List list2) {
        final List result = newArrayList();
        for (final E item : list1) {
            if (!list2.contains(item)) {
                result.add(item);
            }
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    public static  List difference(final List list, final List ... lists) {
        final Deque> stack = new ArrayDeque>();
        stack.push(list);
        for (List es : lists) {
            stack.push(difference(stack.peek(), es));
        }
        return stack.peek();
    }

    @SuppressWarnings("unchecked")
    public List differenceWith(final List ... lists) {
        return difference(newArrayList(iterable), lists);
    }

    @SuppressWarnings("unchecked")
    public static  E[] difference(final E[] ... arrays) {
        final Deque> stack = new ArrayDeque>();
        stack.push(Arrays.asList(arrays[0]));
        for (int index = 1; index < arrays.length; index += 1) {
            stack.push(difference(stack.peek(), Arrays.asList(arrays[index])));
        }
        return (E[]) stack.peek().toArray();
    }

    /*
     * Documented, #zip
     */
    @SuppressWarnings("unchecked")
    public static  List> zip(final List ... lists) {
        final List> zipped = newArrayList();
        each(Arrays.asList(lists), new Consumer>() {
            @Override
            public void accept(final List list) {
                int index = 0;
                for (T elem : list) {
                    final List nTuple = index >= zipped.size() ? U.newArrayList() : zipped.get(index);
                    if (index >= zipped.size()) {
                        zipped.add(nTuple);
                    }
                    index += 1;
                    nTuple.add(elem);
                }
            }
        });
        return zipped;
    }

    @SuppressWarnings("unchecked")
    public static  List> unzip(final List ... lists) {
        final List> unzipped = newArrayList();
        for (int index = 0; index < lists[0].size(); index += 1) {
            final List nTuple = newArrayList();
            for (List list : lists) {
                nTuple.add(list.get(index));
            }
            unzipped.add(nTuple);
        }
        return unzipped;
    }

    /*
     * Documented, #object
     */
    public static  List> object(final List keys, final List values) {
        return map(keys, new Function>() {
            private int index;

            @Override
            public Tuple apply(K key) {
                return Tuple.create(key, values.get(index++));
            }
        });
    }

    public static  int findIndex(final List list, final Predicate pred) {
        for (int index = 0; index < list.size(); index++) {
            if (pred.test(list.get(index))) {
                return index;
            }
        }
        return -1;
    }

    public static  int findIndex(final E[] array, final Predicate pred) {
        return findIndex(Arrays.asList(array), pred);
    }

    public static  int findLastIndex(final List list, final Predicate pred) {
        for (int index = list.size() - 1; index >= 0; index--) {
            if (pred.test(list.get(index))) {
                return index;
            }
        }
        return -1;
    }

    public static  int findLastIndex(final E[] array, final Predicate pred) {
        return findLastIndex(Arrays.asList(array), pred);
    }

    public static > int binarySearch(final Iterable iterable, final E key) {
        if (key == null) {
            return first(iterable) == null ? 0 : -1;
        }
        int begin = 0;
        int end = size(iterable) - 1;
        int numberOfNullValues = 0;
        List list = new ArrayList();
        for (E item : iterable) {
            if (item == null) {
                numberOfNullValues++;
                end--;
            } else {
                list.add(item);
            }
        }
        while (begin <= end) {
            int middle = begin + (end - begin) / 2;
            if (key.compareTo(list.get(middle)) < 0) {
                end = middle - 1;
            } else if (key.compareTo(list.get(middle)) > 0) {
                begin = middle + 1;
            } else {
                return middle + numberOfNullValues;
            }
        }
        return -(begin + numberOfNullValues + 1);
    }

    public static > int binarySearch(final E[] array, final E key) {
        return binarySearch(Arrays.asList(array), key);
    }

    /*
     * Documented, #sortedIndex
     */
    public static > int sortedIndex(final List list, final E value) {
        int index = 0;
        for (E elem : list) {
            if (elem.compareTo(value) >= 0) {
                return index;
            }
            index += 1;
        }
        return -1;
    }

    public static > int sortedIndex(final E[] array, final E value) {
        return sortedIndex(Arrays.asList(array), value);
    }

    @SuppressWarnings("unchecked")
    public static > int sortedIndex(final List list, final E value,
        final String propertyName) {
        try {
            final Field property = value.getClass().getField(propertyName);
            final Object valueProperty = property.get(value);
            int index = 0;
            for (E elem : list) {
                if (((Comparable) property.get(elem)).compareTo(valueProperty) >= 0) {
                    return index;
                }
                index += 1;
            }
            return -1;
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static > int sortedIndex(final E[] array, final E value,
        final String propertyName) {
        return sortedIndex(Arrays.asList(array), value, propertyName);
    }

    /*
     * Documented, #indexOf
     */
    public static  int indexOf(final List list, final E value) {
        return list.indexOf(value);
    }

    public static  int indexOf(final E[] array, final E value) {
        return indexOf(Arrays.asList(array), value);
    }

    /*
     * Documented, #lastIndexOf
     */
    public static  int lastIndexOf(final List list, final E value) {
        return list.lastIndexOf(value);
    }

    public static  int lastIndexOf(final E[] array, final E value) {
        return lastIndexOf(Arrays.asList(array), value);
    }

    /*
     * Documented, #range
     */
    public static List range(int stop) {
        return range(0, stop, 1);
    }

    public static List range(int start, int stop) {
        return range(start, stop, start < stop ? 1 : -1);
    }

    public static List range(int start, int stop, int step) {
        List list = U.newArrayList();
        if (step == 0) {
             return list;
        }
        if (start < stop) {
            for (int value = start; value < stop; value += step) {
                list.add(value);
            }
        } else {
            for (int value = start; value > stop; value += step) {
                list.add(value);
            }
        }
        return list;
    }

    public static List range(char stop) {
        return range('a', stop, 1);
    }

    public static List range(char start, char stop) {
        return range(start, stop, start < stop ? 1 : -1);
    }

    public static List range(char start, char stop, int step) {
        List list = U.newArrayList();
        if (step == 0) {
             return list;
        }
        if (start < stop) {
            for (char value = start; value < stop; value += step) {
                list.add(value);
            }
        } else {
            for (char value = start; value > stop; value += step) {
                list.add(value);
            }
        }
        return list;
    }

    public static  List> chunk(final Iterable iterable, final int size) {
         if (size <= 0) {
            return newArrayList();
         }
         return chunk(iterable, size, size);
    }

    public static  List> chunk(final Iterable iterable, final int size, final int step) {
        if (step <= 0 || size < 0) {
            return newArrayList();
        }
        int index = 0;
        int length = size(iterable);
        final List> result = new ArrayList>(size == 0 ? size : (length / size) + 1);
        while (index < length) {
            result.add(newArrayList(iterable).subList(index, Math.min(length, index + size)));
            index += step;
        }
        return result;
    }

    public static  List> chunkFill(final Iterable iterable, final int size, final T fillValue) {
        if (size <= 0) {
            return newArrayList();
        }
        return chunkFill(iterable, size, size, fillValue);
    }

    public static  List> chunkFill(final Iterable iterable, final int size,
        final int step, final T fillValue) {
        if (step <= 0 || size < 0) {
            return newArrayList();
        }
        final List> result = chunk(iterable, size, step);
        int difference = size - result.get(result.size() - 1).size();
        for (int i = difference; 0 < i; i--) {
            result.get(result.size() - 1).add(fillValue);
        }
        return result;
    }

    public List> chunk(final int size) {
        return chunk(getIterable(), size, size);
    }

    public List> chunk(final int size, final int step) {
        return chunk(getIterable(), size, step);
    }

    public List> chunkFill(final int size, final T fillvalue) {
        return chunkFill(getIterable(), size, size, fillvalue);
    }

    public List> chunkFill(final int size, final int step, T fillvalue) {
        return chunkFill(getIterable(), size, step, fillvalue);
    }

    public static  List cycle(final Iterable iterable, final int times) {
        int size = Math.abs(size(iterable) * times);
        if (size == 0) {
            return newArrayList();
        }
        List list = newArrayListWithExpectedSize(size);
        int round = 0;
        if (times > 0) {
            while (round < times) {
                for (T element : iterable) {
                    list.add(element);
                }
                round++;
            }
        } else {
            list = cycle(U.reverse(iterable), -times);
        }
        return list;
    }

    public List cycle(final int times) {
        return cycle(value(), times);
    }

    public static  List repeat(final T element, final int times) {
        if (times <= 0) {
            return newArrayList();
        }
        List result = newArrayListWithExpectedSize(times);
        for (int i = 0; i < times; i++) {
            result.add(element);
        }
        return result;
    }

    public static  List interpose(final Iterable iterable, final T interElement) {
        if (interElement == null) {
            return newArrayList(iterable);
        }
        int size = size(iterable);
        int index = 0;
        List array = newArrayListWithExpectedSize(size * 2);
        for (T elem : iterable) {
            array.add(elem);
            if (index + 1 < size) {
                array.add(interElement);
                index++;
            }
        }
        return array;
    }

    public static  List interposeByList(final Iterable iterable, final Iterable interIter) {
        if (interIter == null) {
            return newArrayList(iterable);
        }
        List interList = newArrayList(interIter);
        if (isEmpty(interIter)) {
            return newArrayList(iterable);
        }
        int size = size(iterable);
        List array = newArrayListWithExpectedSize(size + interList.size());
        int index = 0;
        for (T element : iterable) {
            array.add(element);
            if (index < interList.size() && index + 1 < size) {
                array.add(interList.get(index));
                index++;
            }
        }
        return array;
    }

    public List interpose(final T element) {
        return interpose(value(), element);
    }

    public List interposeByList(final Iterable interIter) {
        return interposeByList(value(), interIter);
    }

    /*
     * Documented, #bind
     */
    public static  Function bind(final Function function) {
        return new Function() {
            @Override
            public T apply(F arg) {
                return function.apply(arg);
            }
        };
    }

    /*
     * Documented, #memoize
     */
    public static  Function memoize(final Function function) {
        return new MemoizeFunction() {
            @Override
            public T calc(F arg) {
                return function.apply(arg);
            }
        };
    }

    /*
     * Documented, #delay
     */
    public static  java.util.concurrent.ScheduledFuture delay(final Supplier function,
        final int delayMilliseconds) {
        final java.util.concurrent.ScheduledExecutorService scheduler =
            java.util.concurrent.Executors.newSingleThreadScheduledExecutor();
        final java.util.concurrent.ScheduledFuture future = scheduler.schedule(
            new java.util.concurrent.Callable() {
                public T call() {
                    return function.get();
                }
            }, delayMilliseconds, java.util.concurrent.TimeUnit.MILLISECONDS);
        scheduler.shutdown();
        return future;
    }

    public static  java.util.concurrent.ScheduledFuture defer(final Supplier function) {
        return delay(function, 0);
    }

    public static java.util.concurrent.ScheduledFuture defer(final Runnable runnable) {
        return delay(new Supplier() {
            @Override
            public Void get() {
                runnable.run();
                return null;
            }
        }, 0);
    }

    public static  Supplier throttle(final Supplier function, final int waitMilliseconds) {
        class ThrottleLater implements Supplier {
            private final Supplier localFunction;
            private java.util.concurrent.ScheduledFuture timeout;
            private long previous;

            ThrottleLater(final Supplier function) {
                this.localFunction = function;
            }

            @Override
            public T get() {
                previous = now();
                timeout = null;
                return localFunction.get();
            }

            java.util.concurrent.ScheduledFuture getTimeout() {
                return timeout;
            }

            void setTimeout(java.util.concurrent.ScheduledFuture timeout) {
                this.timeout = timeout;
            }

            long getPrevious() {
                return previous;
            }

            void setPrevious(long previous) {
                this.previous = previous;
            }
        }

        class ThrottleFunction implements Supplier {
            private final Supplier localFunction;
            private final ThrottleLater throttleLater;

            ThrottleFunction(final Supplier function) {
                this.localFunction = function;
                this.throttleLater = new ThrottleLater(function);
            }

            @Override
            public T get() {
                final long now = now();
                if (throttleLater.getPrevious() == 0L) {
                    throttleLater.setPrevious(now);
                }
                final long remaining = waitMilliseconds - (now - throttleLater.getPrevious());
                T result = null;
                if (remaining <= 0) {
                    throttleLater.setPrevious(now);
                    result = localFunction.get();
                } else if (throttleLater.getTimeout() == null) {
                    throttleLater.setTimeout(delay(throttleLater, waitMilliseconds));
                }
                return result;
            }
        }
        return new ThrottleFunction(function);
    }

    /*
     * Documented, #debounce
     */
    public static  Supplier debounce(final Supplier function, final int delayMilliseconds) {
        return new Supplier() {
            private java.util.concurrent.ScheduledFuture timeout;

            @Override
            public T get() {
                clearTimeout(timeout);
                timeout = delay(function, delayMilliseconds);
                return null;
            }
        };
    }

    /*
     * Documented, #wrap
     */
    public static  Function wrap(final Function function,
        final Function, T> wrapper) {
        return new Function() {
            public T apply(final Void arg) {
                return wrapper.apply(function);
            }
        };
    }

    public static  Predicate negate(final Predicate pred) {
        return new Predicate() {
            public boolean test(final E item) {
                return !pred.test(item);
            }
        };
    }

    /*
     * Documented, #compose
     */
    @SuppressWarnings("unchecked")
    public static  Function compose(final Function ... func) {
        return new Function() {
            public T apply(final T arg) {
                T result = arg;
                for (int index = func.length - 1; index >= 0; index -= 1) {
                    result = func[index].apply(result);
                }
                return result;
            }
        };
    }

    /*
     * Documented, #after
     */
    public static  Supplier after(final int count, final Supplier function) {
        class AfterFunction implements Supplier {
            private final int count;
            private final Supplier localFunction;
            private int index;
            private E result;

            AfterFunction(final int count, final Supplier function) {
                this.count = count;
                this.localFunction = function;
            }
            public E get() {
                if (++index >= count) {
                    result = localFunction.get();
                }
                return result;
            }
        }
        return new AfterFunction(count, function);
    }

    /*
     * Documented, #before
     */
    public static  Supplier before(final int count, final Supplier function) {
        class BeforeFunction implements Supplier {
            private final int count;
            private final Supplier localFunction;
            private int index;
            private E result;

            BeforeFunction(final int count, final Supplier function) {
                this.count = count;
                this.localFunction = function;
            }
            public E get() {
                if (++index <= count) {
                    result = localFunction.get();
                }
                return result;
            }
        }
        return new BeforeFunction(count, function);
    }

    /*
     * Documented, #once
     */
    public static  Supplier once(final Supplier function) {
        return new Supplier() {
            private volatile boolean executed;
            private T result;
            @Override
            public T get() {
                if (!executed) {
                    executed = true;
                    result = function.get();
                }
                return result;
            }
        };
    }

    /*
     * Documented, #keys
     */
    public static  Set keys(final Map object) {
        return object.keySet();
    }

    /*
     * Documented, #values
     */
    public static  Collection values(final Map object) {
        return object.values();
    }

    public static  List> mapObject(final Map object, final Function func) {
        return map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                return Tuple.create(entry.getKey(), func.apply(entry.getValue()));
            }
        });
    }

    /*
     * Documented, #pairs
     */
    public static  List> pairs(final Map object) {
        return map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                return Tuple.create(entry.getKey(), entry.getValue());
            }
        });
    }

    /*
     * Documented, #invert
     */
    public static  List> invert(final Map object) {
        return map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                return Tuple.create(entry.getValue(), entry.getKey());
            }
        });
    }

    /*
     * Documented, #functions
     */
    public static List functions(final Object object) {
        final List result = newArrayList();
        for (final Method method : object.getClass().getDeclaredMethods()) {
            result.add(method.getName());
        }
        return sort(uniq(result));
    }

    public static List methods(final Object object) {
        return functions(object);
    }

    /*
     * Documented, #extend
     */
    @SuppressWarnings("unchecked")
    public static  Map extend(final Map destination, final Map ... sources) {
        final Map result = newLinkedHashMap();
        for (final Map.Entry entry : destination.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        for (final Map source : sources) {
            for (final Map.Entry entry : source.entrySet()) {
                result.put(entry.getKey(), entry.getValue());
            }
        }
        return result;
    }

    public static  E findKey(final List list, final Predicate pred) {
        for (E e : list) {
            if (pred.test(e)) {
                return e;
            }
        }
        return null;
    }

    public static  E findKey(final E[] array, final Predicate pred) {
        return findKey(Arrays.asList(array), pred);
    }

    public static  E findLastKey(final List list, final Predicate pred) {
        for (int index = list.size() - 1; index >= 0; index--) {
            if (pred.test(list.get(index))) {
                return list.get(index);
            }
        }
        return null;
    }

    public static  E findLastKey(final E[] array, final Predicate pred) {
        return findLastKey(Arrays.asList(array), pred);
    }

    /*
     * Documented, #pick
     */
    @SuppressWarnings("unchecked")
    public static  List> pick(final Map object, final K ... keys) {
        return without(map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                if (Arrays.asList(keys).contains(entry.getKey())) {
                    return Tuple.create(entry.getKey(), entry.getValue());
                } else {
                    return null;
                }
            }
        }), (Tuple) null);
    }

    @SuppressWarnings("unchecked")
    public static  List> pick(final Map object, final Predicate pred) {
        return without(map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                if (pred.test(object.get(entry.getKey()))) {
                    return Tuple.create(entry.getKey(), entry.getValue());
                } else {
                    return null;
                }
            }
        }), (Tuple) null);
    }

    /*
     * Documented, #omit
     */
    @SuppressWarnings("unchecked")
    public static  List> omit(final Map object, final K ... keys) {
        return without(map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                if (Arrays.asList(keys).contains(entry.getKey())) {
                    return null;
                } else {
                    return Tuple.create(entry.getKey(), entry.getValue());
                }
            }
        }), (Tuple) null);
    }

    @SuppressWarnings("unchecked")
    public static  List> omit(final Map object, final Predicate pred) {
        return without(map(newArrayList(object.entrySet()), new Function, Tuple>() {
            @Override
            public Tuple apply(Map.Entry entry) {
                if (pred.test(entry.getValue())) {
                    return null;
                } else {
                    return Tuple.create(entry.getKey(), entry.getValue());
                }
            }
        }), (Tuple) null);
    }

    /*
     * Documented, #defaults
     */
    public static  Map defaults(final Map object, final Map defaults) {
        final Map result = newLinkedHashMap();
        for (final Map.Entry entry : defaults.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        for (final Map.Entry entry : object.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    /*
     * Documented, #clone
     */
    public static Object clone(final Object obj) {
        try {
            if (obj instanceof Cloneable) {
                for (final Method method : obj.getClass().getMethods()) {
                    if (method.getName().equals("clone") && method.getParameterTypes().length == 0) {
                        return method.invoke(obj);
                    }
                }
            }
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
        throw new IllegalArgumentException("Cannot clone object");
    }

    @SuppressWarnings("unchecked")
    public static  E[] clone(final E ... iterable) {
        return Arrays.copyOf(iterable, iterable.length);
    }

    public static  void tap(final Iterable iterable, final Consumer func) {
        each(iterable, func);
    }

    public static  boolean isMatch(final Map object, final Map properties) {
        for (final K key : keys(properties)) {
            if (!object.containsKey(key) || !object.get(key).equals(properties.get(key))) {
                return false;
            }
        }
        return true;
    }

    /*
     * Documented, #isEqual
     */
    public static boolean isEqual(final Object object, final Object other) {
        return object == null ? other == null : object.equals(other);
    }

    public static  boolean isEmpty(final Map object) {
        return object == null || object.isEmpty();
    }

    /*
     * Documented, #isEmpty
     */
    public static  boolean isEmpty(final Iterable iterable) {
        return iterable == null || !iterable.iterator().hasNext();
    }

    public boolean isEmpty() {
        return iterable == null || !iterable.iterator().hasNext();
    }

    public static  boolean isNotEmpty(final Map object) {
        return object != null && !object.isEmpty();
    }

    public static  boolean isNotEmpty(final Iterable iterable) {
        return iterable != null && iterable.iterator().hasNext();
    }

    public boolean isNotEmpty() {
        return iterable != null && iterable.iterator().hasNext();
    }

    /*
     * Documented, #isArray
     */
    public static boolean isArray(final Object object) {
        return object != null && object.getClass().isArray();
    }

    /*
     * Documented, #isObject
     */
    public static boolean isObject(final Object object) {
        return object instanceof Map;
    }

    /*
     * Documented, #isFunction
     */
    public static boolean isFunction(final Object object) {
        return object instanceof Function;
    }

    /*
     * Documented, #isString
     */
    public static boolean isString(final Object object) {
        return object instanceof String;
    }

    /*
     * Documented, #isNumber
     */
    public static boolean isNumber(final Object object) {
        return object instanceof Number;
    }

    /*
     * Documented, #isDate
     */
    public static boolean isDate(final Object object) {
        return object instanceof Date;
    }

    public static boolean isRegExp(final Object object) {
        return object instanceof java.util.regex.Pattern;
    }

    public static boolean isError(final Object object) {
        return object instanceof Throwable;
    }

    /*
     * Documented, #isBoolean
     */
    public static boolean isBoolean(final Object object) {
        return object instanceof Boolean;
    }

    public static boolean isNull(final Object object) {
        return object == null;
    }

    /*
     * Documented, #has
     */
    public static  boolean has(final Map object, final K key) {
        return object.containsKey(key);
    }

    public static  E identity(final E value) {
        return value;
    }

    public static  Supplier constant(final E value) {
        return new Supplier() {
            public E get() {
                return value;
            }
        };
    }

    public static  Function, V> property(final K key) {
        return new Function, V>() {
            public V apply(final Map object) {
                return object.get(key);
            }
        };
    }

    public static  Function propertyOf(final Map object) {
        return new Function() {
            public V apply(final K key) {
                return object.get(key);
            }
        };
    }

    public static  Predicate> matcher(final Map object) {
        return new Predicate>() {
            public boolean test(final Map item) {
                for (final K key : keys(object)) {
                    if (!item.containsKey(key) || !item.get(key).equals(object.get(key))) {
                        return false;
                    }
                }
                return true;
            }
        };
    }

    /*
     * Documented, #times
     */
    public static void times(final int count, final Runnable runnable) {
        for (int index = 0; index < count; index += 1) {
            runnable.run();
        }
    }

    /*
     * Documented, #random
     */
    public static int random(final int min, final int max) {
        return min + new java.security.SecureRandom().nextInt(max - min + 1);
    }

    public static int random(final int max) {
        return new java.security.SecureRandom().nextInt(max + 1);
    }

    public static long now() {
        return new Date().getTime();
    }

    /*
     * Documented, #escape
     */
    public static String escape(final String value) {
        final StringBuilder builder = new StringBuilder();
        for (final char ch : value.toCharArray()) {
            builder.append(ESCAPES.containsKey(ch) ? ESCAPES.get(ch) : ch);
        }
        return builder.toString();
    }

    public static String unescape(final String value) {
        return value.replaceAll("`", "`").replaceAll("'", "'").replaceAll("<", "<")
            .replaceAll(">", ">").replaceAll(""", "\"").replaceAll("&", "&");
    }

    /*
     * Documented, #result
     */
    public static  Object result(final Iterable iterable, final Predicate pred) {
        for (E element : iterable) {
            if (pred.test(element)) {
                if (element instanceof Map.Entry) {
                    if (((Map.Entry) element).getValue() instanceof Supplier) {
                        return ((Supplier) ((Map.Entry) element).getValue()).get();
                    }
                    return ((Map.Entry) element).getValue();
                }
                return element;
            }
        }
        return null;
    }

    /*
     * Documented, #uniqueId
     */
    public static String uniqueId(final String prefix) {
        return (prefix == null ? "" : prefix) + UNIQUE_ID.incrementAndGet();
    }

    /*
     * Documented, #uniquePassword
     */
    public static String uniquePassword() {
        final String[] passwords = new String[] {
            "ALKJVBPIQYTUIWEBVPQALZVKQRWORTUYOYISHFLKAJMZNXBVMNFGAHKJSDFALAPOQIERIUYTGSFGKMZNXBVJAHGFAKX",
            "1234567890",
            "qpowiealksdjzmxnvbfghsdjtreiuowiruksfhksajmzxncbvlaksjdhgqwetytopskjhfgvbcnmzxalksjdfhgbvzm",
            ".@,-+/()#$%^&*!"
        };
        final StringBuilder result = new StringBuilder();
        final long passwordLength = Math.abs(UUID.randomUUID().getLeastSignificantBits() % MIN_PASSWORD_LENGTH_8)
            + MIN_PASSWORD_LENGTH_8;
        for (int index = 0; index < passwordLength; index += 1) {
            final int passIndex = (int) (passwords.length * (long) index / passwordLength);
            final int charIndex = (int) Math.abs(
                UUID.randomUUID().getLeastSignificantBits() % passwords[passIndex].length());
            result.append(passwords[passIndex].charAt(charIndex));
        }
        return result.toString();
    }

    public static  Template> template(final String template) {
        return new TemplateImpl(template);
    }

    public static String format(final String template, final Object ... params) {
        final java.util.regex.Matcher matcher = FORMAT_PATTERN.matcher(template);
        final StringBuffer buffer = new StringBuffer();
        int index = 0;
        while (matcher.find()) {
            if (matcher.group(1).isEmpty()) {
                matcher.appendReplacement(buffer, "<%" + index++ + "%>");
            } else {
                matcher.appendReplacement(buffer, "<%" + matcher.group(1) + "%>");
            }
        }
        matcher.appendTail(buffer);
        final String newTemplate = buffer.toString();
        final Map args = newLinkedHashMap();
        index = 0;
        for (Object param : params) {
            args.put(index, param.toString());
            index += 1;
        }
        return new TemplateImpl(newTemplate).apply(args);
    }

    public static  Iterable iterate(final T seed, final UnaryOperator unaryOperator) {
        return new MyIterable(seed, unaryOperator);
    }

    /*
     * Documented, #chain
     */
    public static  Chain chain(final List list) {
        return new U.Chain(list);
    }

    public static  Chain chain(final Iterable iterable) {
        return new U.Chain(newArrayList(iterable));
    }

    public static  Chain chain(final Iterable iterable, int size) {
        return new U.Chain(newArrayList(iterable, size));
    }

    @SuppressWarnings("unchecked")
    public static  Chain chain(final T ... array) {
        return new U.Chain(Arrays.asList(array));
    }

    public static Chain chain(final int[] array) {
        return new U.Chain(newIntegerList(array));
    }

    public Chain chain() {
        return new U.Chain(newArrayList(iterable));
    }

    public static  Chain of(final List list) {
        return new U.Chain(list);
    }

    public static  Chain of(final Iterable iterable) {
        return new U.Chain(newArrayList(iterable));
    }

    public static  Chain of(final Iterable iterable, int size) {
        return new U.Chain(newArrayList(iterable, size));
    }

    @SuppressWarnings("unchecked")
    public static  Chain of(final T ... array) {
        return new U.Chain(Arrays.asList(array));
    }

    public static Chain of(final int[] array) {
        return new U.Chain(newIntegerList(array));
    }

    public Chain of() {
        return new U.Chain(newArrayList(iterable));
    }

    public static class Chain {
        private final T item;
        private final List list;
        public Chain(final T item) {
            this.item = item;
            this.list = null;
        }
        public Chain(final List list) {
            this.item = null;
            this.list = list;
        }

        public Chain first() {
            return new Chain(U.first(list));
        }

        public Chain first(int n) {
            return new Chain(U.first(list, n));
        }

        public Chain first(final Predicate pred) {
            return new Chain(U.first(list, pred));
        }

        public Chain first(final Predicate pred, int n) {
            return new Chain(U.first(list, pred, n));
        }

        public Chain firstOrNull() {
            return new Chain(U.firstOrNull(list));
        }

        public Chain firstOrNull(final Predicate pred) {
            return new Chain(U.firstOrNull(list, pred));
        }

        public Chain initial() {
            return new Chain(U.initial(list));
        }

        public Chain initial(int n) {
            return new Chain(U.initial(list, n));
        }

        public Chain last() {
            return new Chain(U.last(list));
        }

        public Chain last(int n) {
            return new Chain(U.last(list, n));
        }

        public Chain lastOrNull() {
            return new Chain(U.lastOrNull(list));
        }

        public Chain lastOrNull(final Predicate pred) {
            return new Chain(U.lastOrNull(list, pred));
        }

        public Chain rest() {
            return new Chain(U.rest(list));
        }

        public Chain rest(int n) {
            return new Chain(U.rest(list, n));
        }

        public Chain compact() {
            return new Chain(U.compact(list));
        }

        public Chain compact(final T falsyValue) {
            return new Chain(U.compact(list, falsyValue));
        }

        @SuppressWarnings("unchecked")
        public Chain flatten() {
            return new Chain(U.flatten(list));
        }

        public  Chain map(final Function func) {
            return new Chain(U.map(list, func));
        }

        public  Chain mapIndexed(final BiFunction func) {
            return new Chain(U.mapIndexed(list, func));
        }

        public Chain replace(final Predicate pred, final T value) {
            return new Chain(U.replace(list, pred, value));
        }

        public Chain replaceIndexed(final PredicateIndexed pred, final T value) {
            return new Chain(U.replaceIndexed(list, pred, value));
        }

        public Chain filter(final Predicate pred) {
            return new Chain(U.filter(list, pred));
        }

        public Chain filterIndexed(final PredicateIndexed pred) {
            return new Chain(U.filterIndexed(list, pred));
        }

        public Chain reject(final Predicate pred) {
            return new Chain(U.reject(list, pred));
        }

        public Chain rejectIndexed(final PredicateIndexed pred) {
            return new Chain(U.rejectIndexed(list, pred));
        }

        public Chain filterFalse(final Predicate pred) {
            return new Chain(U.reject(list, pred));
        }

        public  Chain reduce(final BiFunction func, final F zeroElem) {
            return new Chain(U.reduce(list, func, zeroElem));
        }

        public Chain> reduce(final BinaryOperator func) {
            return new Chain>(U.reduce(list, func));
        }

        public  Chain reduceRight(final BiFunction func, final F zeroElem) {
            return new Chain(U.reduceRight(list, func, zeroElem));
        }

        public Chain> reduceRight(final BinaryOperator func) {
            return new Chain>(U.reduceRight(list, func));
        }

        public Chain> find(final Predicate pred) {
            return new Chain>(U.find(list, pred));
        }

        public Chain> findLast(final Predicate pred) {
            return new Chain>(U.findLast(list, pred));
        }

        @SuppressWarnings("unchecked")
        public Chain max() {
            return new Chain(U.max((Collection) list));
        }

        public > Chain max(final Function func) {
            return new Chain(U.max(list, func));
        }

        @SuppressWarnings("unchecked")
        public Chain min() {
            return new Chain(U.min((Collection) list));
        }

        public > Chain min(final Function func) {
            return new Chain(U.min(list, func));
        }

        @SuppressWarnings("unchecked")
        public Chain sort() {
            return new Chain(U.sort((List) list));
        }

        @SuppressWarnings("unchecked")
        public > Chain sortWith(final Comparator comparator) {
            return new Chain(U.sortWith((List) list, comparator));
        }

        public > Chain sortBy(final Function func) {
            return new Chain(U.sortBy(list, func));
        }

        @SuppressWarnings("unchecked")
        public  Chain> sortBy(final K key) {
            return new Chain>(U.sortBy((List>) list, key));
        }

        public  Chain>> groupBy(final Function func) {
            return new Chain>>(U.groupBy(list, func));
        }

        public  Chain>> groupBy(final Function func,
            final BinaryOperator binaryOperator) {
            return new Chain>>(U.groupBy(list, func, binaryOperator));
        }

        public Chain>> indexBy(final String property) {
            return new Chain>>(U.indexBy(list, property));
        }

        public  Chain> countBy(final Function func) {
            return new Chain>(U.countBy(list, func));
        }

        public Chain> countBy() {
            return new Chain>(U.countBy(list));
        }

        public Chain shuffle() {
            return new Chain(U.shuffle(list));
        }

        public Chain sample() {
            return new Chain(U.sample(list));
        }

        public Chain sample(final int howMany) {
            return new Chain(U.newArrayList(U.sample(list, howMany)));
        }

        public Chain tap(final Consumer func) {
            U.each(list, func);
            return new Chain(list);
        }

        public Chain forEach(final Consumer func) {
            U.each(list, func);
            return new Chain(list);
        }

        public Chain forEachRight(final Consumer func) {
            U.eachRight(list, func);
            return new Chain(list);
        }

        public Chain every(final Predicate pred) {
            return new Chain(U.every(list, pred));
        }

        public Chain some(final Predicate pred) {
            return new Chain(U.some(list, pred));
        }

        public Chain count(final Predicate pred) {
            return new Chain(U.count(list, pred));
        }

        public Chain contains(final T elem) {
            return new Chain(U.contains(list, elem));
        }

        public Chain containsWith(final T elem) {
            return new Chain(U.containsWith(list, elem));
        }

        public Chain invoke(final String methodName, final List args) {
            return new Chain(U.invoke(list, methodName, args));
        }

        public Chain invoke(final String methodName) {
            return new Chain(U.invoke(list, methodName));
        }

        public Chain pluck(final String propertyName) {
            return new Chain(U.pluck(list, propertyName));
        }

        public  Chain where(final List> properties) {
            return new Chain(U.where(list, properties));
        }

        public  Chain> findWhere(final List> properties) {
            return new Chain>(U.findWhere(list, properties));
        }

        public Chain uniq() {
            return new Chain(U.uniq(list));
        }

        public  Chain uniq(final Function func) {
            return new Chain(U.newArrayList(U.uniq(list, func)));
        }

        public Chain distinct() {
            return new Chain(U.uniq(list));
        }

        @SuppressWarnings("unchecked")
        public  Chain distinctBy(final Function func) {
            return new Chain(U.newArrayList((Iterable) U.uniq(list, func)));
        }

        @SuppressWarnings("unchecked")
        public Chain union(final List ... lists) {
            return new Chain(U.union(list, lists));
        }

        @SuppressWarnings("unchecked")
        public Chain intersection(final List ... lists) {
            return new Chain(U.intersection(list, lists));
        }

        @SuppressWarnings("unchecked")
        public Chain difference(final List ... lists) {
            return new Chain(U.difference(list, lists));
        }

        public Chain range(final int stop) {
            return new Chain(U.range(stop));
        }

        public Chain range(final int start, final int stop) {
            return new Chain(U.range(start, stop));
        }

        public Chain range(final int start, final int stop, final int step) {
            return new Chain(U.range(start, stop, step));
        }

        public Chain> chunk(final int size) {
            return new Chain>(U.chunk(value(), size, size));
        }

        public Chain> chunk(final int size, final int step) {
            return new Chain>(U.chunk(value(), size, step));
        }

        public Chain> chunkFill(final int size, final T fillValue) {
            return new Chain>(U.chunkFill(value(), size, size, fillValue));
        }

        public Chain> chunkFill(final int size, final int step, final T fillValue) {
            return new Chain>(U.chunkFill(value(), size, step, fillValue));
        }

        public Chain cycle(final int times) {
            return new Chain(U.cycle(value(), times));
        }

        public Chain interpose(final T element) {
            return new Chain(U.interpose(value(), element));
        }

        public Chain interposeByList(final Iterable interIter) {
            return new Chain(U.interposeByList(value(), interIter));
        }

        @SuppressWarnings("unchecked")
        public Chain concat(final List ... lists) {
            return new Chain(U.concat(list, lists));
        }

        public Chain slice(final int start) {
            return new Chain(U.slice(list, start));
        }

        public Chain slice(final int start, final int end) {
            return new Chain(U.slice(list, start, end));
        }

        public Chain> splitAt(final int position) {
            return new Chain>(U.splitAt(list, position));
        }

        public Chain takeSkipping(final int stepSize) {
            return new Chain(U.takeSkipping(list, stepSize));
        }

        public Chain reverse() {
            return new Chain(U.reverse(list));
        }

        public Chain join() {
            return new Chain(U.join(list));
        }

        public Chain join(final String separator) {
            return new Chain(U.join(list, separator));
        }

        @SuppressWarnings("unchecked")
        public Chain push(final T ... values) {
            return new Chain(U.push(value(), values));
        }

        public Chain>> pop() {
            return new Chain>>(U.pop(value()));
        }

        public Chain>> shift() {
            return new Chain>>(U.shift(value()));
        }

        @SuppressWarnings("unchecked")
        public Chain unshift(final T ... values) {
            return new Chain(U.unshift(value(), values));
        }

        public Chain skip(final int numberToSkip) {
            return new Chain(list.subList(numberToSkip, list.size()));
        }

        public Chain limit(final int size) {
            return new Chain(U.first(list, size));
        }

        @SuppressWarnings("unchecked")
        public  Chain> toMap() {
            return new Chain>(U.toMap((Iterable>) list));
        }

        public boolean isEmpty() {
            return U.isEmpty(list);
        }

        public boolean isNotEmpty() {
            return U.isNotEmpty(list);
        }

        public int size() {
            return U.size(list);
        }

        public T item() {
            return item;
        }

        /*
         * Documented, #value
         */
        public List value() {
            return list;
        }

        public List toList() {
            return list;
        }

        public String toString() {
            return String.valueOf(list);
        }
    }

    /*
     * Documented, #mixin
     */
    public static void mixin(final String funcName, final Function func) {
        FUNCTIONS.put(funcName, func);
    }

    public Optional call(final String funcName) {
        if (string.isPresent() && FUNCTIONS.containsKey(funcName)) {
            return Optional.of(FUNCTIONS.get(funcName).apply(string.get()));
        }
        return Optional.absent();
    }

    public static > List sort(final Iterable iterable) {
        final List localList = newArrayList(iterable);
        Collections.sort(localList);
        return localList;
    }

    @SuppressWarnings("unchecked")
    public static > T[] sort(final T ... array) {
        final T[] localArray = array.clone();
        Arrays.sort(localArray);
        return localArray;
    }

    @SuppressWarnings("unchecked")
    public List sort() {
        return sort((Iterable) iterable);
    }

    /*
     * Documented, #join
     */
    public static  String join(final Iterable iterable, final String separator) {
        final StringBuilder sb = new StringBuilder();
        int index = 0;
        for (final T item : iterable) {
            if (index > 0) {
                sb.append(separator);
            }
            sb.append(item.toString());
            index += 1;
        }
        return sb.toString();
    }

    public static  String join(final Iterable iterable) {
        return join(iterable, " ");
    }

    public static  String join(final T[] array, final String separator) {
        return join(Arrays.asList(array), separator);
    }

    public static  String join(final T[] array) {
        return join(array, " ");
    }

    public String join(final String separator) {
        return join(iterable, separator);
    }

    public String join() {
        return join(iterable);
    }

    @SuppressWarnings("unchecked")
    public static  List push(final List list, final T ... values) {
        final List result = newArrayList(list);
        for (T value : values) {
            result.add(value);
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    public List push(final T ... values) {
        return push((List) getIterable(), values);
    }

    public static  Tuple> pop(final List list) {
        return Tuple.create(last(list), initial(list));
    }

    public Tuple> pop() {
        return pop((List) getIterable());
    }

    @SuppressWarnings("unchecked")
    public static  List unshift(final List list, final T ... values) {
        final List result = newArrayList(list);
        int index = 0;
        for (T value : values) {
            result.add(index, value);
            index += 1;
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    public List unshift(final T ... values) {
        return unshift((List) getIterable(), values);
    }

    public static  Tuple> shift(final List list) {
        return Tuple.create(first(list), rest(list));
    }

    public Tuple> shift() {
        return shift((List) getIterable());
    }

    @SuppressWarnings("unchecked")
    public static  T[] concat(final T[] first, final T[] ... other) {
        int length = 0;
        for (T[] otherItem : other) {
            length += otherItem.length;
        }
        final T[] result = Arrays.copyOf(first, first.length + length);
        int index = 0;
        for (T[] otherItem : other) {
            System.arraycopy(otherItem, 0, result, first.length + index, otherItem.length);
            index += otherItem.length;
        }
        return result;
    }

    /*
     * Documented, #concat
     */
    @SuppressWarnings("unchecked")
    public static  List concat(final Iterable first, final Iterable ... other) {
        List list = newArrayList(first);
        for (Iterable iter : other) {
            list.addAll(newArrayList(iter));
        }
        return list;
    }

    @SuppressWarnings("unchecked")
    public List concatWith(final Iterable ... other) {
        return concat(iterable, other);
    }

    /*
     * Documented, #slice
     */
    public static  List slice(final Iterable iterable, final int start) {
        final List result;
        if (start >= 0) {
            result = newArrayList(iterable).subList(start, size(iterable));
        } else {
            result = newArrayList(iterable).subList(size(iterable) + start, size(iterable));
        }
        return result;
    }

    public static  T[] slice(final T[] array, final int start) {
        final T[] result;
        if (start >= 0) {
            result = Arrays.copyOfRange(array, start, array.length);
        } else {
            result = Arrays.copyOfRange(array, array.length + start, array.length);
        }
        return result;
    }

    public List slice(final int start) {
        return slice(iterable, start);
    }

    public static  List slice(final Iterable iterable, final int start, final int end) {
        final List result;
        if (start >= 0) {
            if (end > 0) {
                result = newArrayList(iterable).subList(start, end);
            } else {
                result = newArrayList(iterable).subList(start, size(iterable) + end);
            }
        } else {
            if (end > 0) {
                result = newArrayList(iterable).subList(size(iterable) + start, end);
            } else {
                result = newArrayList(iterable).subList(size(iterable) + start, size(iterable) + end);
            }
        }
        return result;
    }

    public static  T[] slice(final T[] array, final int start, final int end) {
        final T[] result;
        if (start >= 0) {
            if (end > 0) {
                result = Arrays.copyOfRange(array, start, end);
            } else {
                result = Arrays.copyOfRange(array, start, array.length + end);
            }
        } else {
            if (end > 0) {
                result = Arrays.copyOfRange(array, array.length + start, end);
            } else {
                result = Arrays.copyOfRange(array, array.length + start, array.length + end);
            }
        }
        return result;
    }

    public List slice(final int start, final int end) {
        return slice(iterable, start, end);
    }

    public static  List> splitAt(final Iterable iterable, final int position) {
        List> result = newArrayList();
        int size = size(iterable);
        final int index;
        if (position < 0) {
            index = 0;
        } else {
            index = position > size ? size : position;
        }
        result.add(newArrayList(iterable).subList(0, index));
        result.add(newArrayList(iterable).subList(index, size));
        return result;
    }

    public static  List> splitAt(final T[] array, final int position) {
        return splitAt(Arrays.asList(array), position);
    }

    public List> splitAt(final int position) {
        return splitAt(iterable, position);
    }

    public static  List takeSkipping(final Iterable iterable, final int stepSize) {
        List result = newArrayList();
        if (stepSize <= 0) {
            return result;
        }
        int size = size(iterable);
        if (stepSize > size) {
            result.add(first(iterable));
            return result;
        }
        int i = 0;
        for (T element : iterable) {
            if (i++ % stepSize == 0) {
                result.add(element);
            }
        }
        return result;
    }

    public static  List takeSkipping(final T[] array, final int stepSize) {
        return takeSkipping(Arrays.asList(array), stepSize);
    }

    public List takeSkipping(final int stepSize) {
        return takeSkipping(iterable, stepSize);
    }

    /*
     * Documented, #reverse
     */
    public static  List reverse(final Iterable iterable) {
        final List result = newArrayList(iterable);
        Collections.reverse(result);
        return result;
    }

    @SuppressWarnings("unchecked")
    public static  T[] reverse(final T ... array) {
        T temp;
        final T[] newArray = array.clone();
        for (int index = 0; index < array.length / 2; index += 1) {
            temp = newArray[index];
            newArray[index] = newArray[array.length - 1 - index];
            newArray[array.length - 1 - index] = temp;
        }
        return newArray;
    }

    public static List reverse(final int[] array) {
        final List result = newIntegerList(array);
        Collections.reverse(result);
        return result;
    }

    public List reverse() {
        return reverse(iterable);
    }

    public Iterable getIterable() {
        return iterable;
    }

    public Iterable value() {
        return iterable;
    }

    public Optional getString() {
        return string;
    }

    public static  java.util.concurrent.ScheduledFuture setTimeout(final Supplier function,
        final int delayMilliseconds) {
        return delay(function, delayMilliseconds);
    }

    public static void clearTimeout(java.util.concurrent.ScheduledFuture scheduledFuture) {
        if (scheduledFuture != null) {
            scheduledFuture.cancel(true);
        }
    }

    public static  java.util.concurrent.ScheduledFuture setInterval(final Supplier function,
        final int delayMilliseconds) {
        final java.util.concurrent.ScheduledExecutorService scheduler =
            java.util.concurrent.Executors.newSingleThreadScheduledExecutor();
        return scheduler.scheduleAtFixedRate(
            new Runnable() {
                public void run() {
                    function.get();
                }
            }, delayMilliseconds, delayMilliseconds, java.util.concurrent.TimeUnit.MILLISECONDS);
    }

    public static void clearInterval(java.util.concurrent.ScheduledFuture scheduledFuture) {
        clearTimeout(scheduledFuture);
    }

    public static  List copyOf(final Iterable iterable) {
        return newArrayList(iterable);
    }

    public List copyOf() {
        return newArrayList(value());
    }

    public static  List copyOfRange(final Iterable iterable, final int start, final int end) {
        return slice(iterable, start, end);
    }

    public List copyOfRange(final int start, final int end) {
        return slice(value(), start, end);
    }

    public static  T elementAt(final List list, final int index) {
        return list.get(index);
    }

    public T elementAt(final int index) {
        return elementAt((List) value(), index);
    }

    public static  T get(final List list, final int index) {
        return elementAt(list, index);
    }

    public T get(final int index) {
        return elementAt((List) value(), index);
    }

    public static  Tuple> set(final List list, final int index, final T value) {
        final List newList = newArrayList(list);
        return Tuple.create(newList.set(index, value), newList);
    }

    public Tuple> set(final int index, final T value) {
        return set((List) value(), index, value);
    }

    public static  T elementAtOrElse(final List list, final int index, T defaultValue) {
        try {
            return list.get(index);
        } catch (IndexOutOfBoundsException ex) {
            return defaultValue;
        }
    }

    public T elementAtOrElse(final int index, T defaultValue) {
        return elementAtOrElse((List) value(), index, defaultValue);
    }

    public static  T elementAtOrNull(final List list, final int index) {
        try {
            return list.get(index);
        } catch (IndexOutOfBoundsException ex) {
            return null;
        }
    }

    public T elementAtOrNull(final int index) {
        return elementAtOrNull((List) value(), index);
    }

    public static  int lastIndex(final Iterable iterable) {
        return size(iterable) - 1;
    }

    public static  int lastIndex(final T[] array) {
        return array.length - 1;
    }

    public static int lastIndex(final int[] array) {
        return array.length - 1;
    }

    public static  T checkNotNull(T reference) {
        if (reference == null) {
            throw new NullPointerException();
        }
        return reference;
    }

    public static  List checkNotNullElements(List references) {
        if (references == null) {
            throw new NullPointerException();
        }
        for (T reference : references) {
            checkNotNull(reference);
        }
        return references;
    }

    public static  T checkNotNull(T reference, Object errorMessage) {
        if (reference == null) {
            throw new NullPointerException(String.valueOf(errorMessage));
        }
        return reference;
    }

    public static boolean nonNull(Object obj) {
        return obj != null;
    }

    public static  T defaultTo(T value, T defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        return value;
    }

    protected static  List newArrayList() {
        return new ArrayList();
    }

    protected static  List newArrayList(final Iterable iterable) {
        final List result;
        if (iterable instanceof Collection) {
            result = new ArrayList((Collection) iterable);
        } else {
            result = new ArrayList();
            for (final T item : iterable) {
                result.add(item);
            }
        }
        return result;
    }

    protected static  List newArrayList(final T object) {
        final List result = new ArrayList();
        result.add(object);
        return result;
    }

    protected static  List newArrayList(final Iterable iterable, final int size) {
        final List result = new ArrayList();
        for (int index = 0; iterable.iterator().hasNext() && index < size; index += 1) {
            result.add(iterable.iterator().next());
        }
        return result;
    }

    protected static List newIntegerList(int ... array) {
        final List result = new ArrayList(array.length);
        for (final int item : array) {
            result.add(item);
        }
        return result;
    }

    protected static  List newArrayListWithExpectedSize(int size) {
        return new ArrayList((int) (CAPACITY_SIZE_5 + size + (size / 10)));
    }

    protected static  Set newLinkedHashSet() {
        return new LinkedHashSet();
    }

    protected static  Set newLinkedHashSet(Iterable iterable) {
        final Set result = new LinkedHashSet();
        for (final T item : iterable) {
            result.add(item);
        }
        return result;
    }

    protected static  Set newLinkedHashSetWithExpectedSize(int size) {
        return new LinkedHashSet((int) Math.max(size * CAPACITY_COEFF_2, CAPACITY_SIZE_16));
    }

    protected static  Map newLinkedHashMap() {
        return new LinkedHashMap();
    }

    @SuppressWarnings("unchecked")
    public static  Predicate and(
            final Predicate pred1,
            final Predicate pred2,
        final Predicate... rest) {
        checkNotNull(pred1);
        checkNotNull(pred2);
        checkNotNullElements(Arrays.asList(rest));
        return new Predicate() {
            @Override
            public boolean test(T value) {
                boolean result = pred1.test(value) && pred2.test(value);
                if (!result) {
                    return false;
                }
                for (Predicate predicate : rest) {
                    if (!predicate.test(value)) {
                        return false;
                    }
                }
                return true;
            }
        };
    }

    @SuppressWarnings("unchecked")
    public static  Predicate or(
            final Predicate pred1,
            final Predicate pred2,
            final Predicate... rest) {
        checkNotNull(pred1);
        checkNotNull(pred2);
        checkNotNullElements(Arrays.asList(rest));
        return new Predicate() {
            @Override
            public boolean test(T value) {
                boolean result = pred1.test(value) || pred2.test(value);
                if (result) {
                    return true;
                }
                for (Predicate predicate : rest) {
                    if (predicate.test(value)) {
                        return true;
                    }
                }
                return false;
            }
        };
    }

    public static int minimumDays(int rows, int columns, List> grid) {
        Queue queue = new LinkedList();
        int cnt = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (grid.get(i).get(j) == 1) {
                    queue.offer(new int[] {i, j});
                    cnt++;
                }
            }
        }
        return getInteger(rows, columns, grid, queue, cnt);
    }

    private static int getInteger(int rows, int columns, List> grid, Queue queue, int cnt) {
        int target = rows * columns;
        int res = 0;
        int localCnt = cnt;
        int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
        while (!queue.isEmpty()) {
            int size = queue.size();
            if (localCnt == target) {
                return res;
            }
            for (int i = 0; i < size; i++) {
                int[] cur = queue.poll();
                for (int[] dir : dirs) {
                    int ni = cur[0] + dir[0];
                    int nj = cur[1] + dir[1];
                    if (ni >= 0 && ni < rows && nj >= 0 && nj < columns && grid.get(ni).get(nj) == 0) {
                        localCnt++;
                        queue.offer(new int[] {ni, nj});
                        grid.get(ni).set(nj, 1);
                    }
                }
            }
            res++;
        }
        return -1;
    }

    public static List topNCompetitors(int numCompetitors, int topNCompetitors, List competitors,
        int numReviews, List reviews) {
        if (U.isNull(reviews) || reviews.isEmpty() || U.isNull(competitors) || competitors.isEmpty()
            || numReviews < 1 || numCompetitors < 1) {
            return new ArrayList();
        }

        List topNCompetitorsList = new ArrayList(topNCompetitors);

        Set competitorsSet = new HashSet(competitors);
        Map topCompetitorsMap = new HashMap();
        List> list = getEntries(reviews, competitorsSet, topCompetitorsMap);

        for (Map.Entry item : list) {
            if (topNCompetitorsList.size() < topNCompetitors) {
                topNCompetitorsList.add(item.getKey());
            } else {
                break;
            }
        }

        return topNCompetitorsList;
    }

    private static List> getEntries(List reviews, Set competitorsSet,
        Map topCompetitorsMap) {
        // clean the reviews first: lowercase, remove special characters and split by spaces.
        for (String review : reviews) {
            String[] reviewArray = review.toLowerCase().replaceAll("[^a-zA-Z0-9 ]", "").split(" ");
            Set tempCompetitorSet = new HashSet();

            for (String text : reviewArray) {
                if (competitorsSet.contains(text) && !tempCompetitorSet.contains(text)) {
                    tempCompetitorSet.add(text);
                    if (topCompetitorsMap.containsKey(text)) {
                        topCompetitorsMap.put(text, topCompetitorsMap.get(text) + 1);
                    } else {
                        topCompetitorsMap.put(text, 1);
                    }
                }
            }
        }

        return getEntries(topCompetitorsMap);
    }

    private static List> getEntries(Map topCompetitorsMap) {
        List> list = new ArrayList>(topCompetitorsMap.entrySet());
        Collections.sort(list, new ValueThenKeyComparator());
        return list;
    }

    public static class ValueThenKeyComparator,
            V extends Comparable> implements Comparator> {

        public int compare(Map.Entry a, Map.Entry b) {
            int cmp1 = b.getValue().compareTo(a.getValue());
            if (cmp1 != 0) {
                return cmp1;
            } else {
                return a.getKey().compareTo(b.getKey());
            }
        }
    }

    public static void main(String ... args) {
        final String message = "Underscore-java8 is a java 8 port of Underscore.js.\n\n"
            + "In addition to porting Underscore's functionality, Underscore-java includes matching unit tests.\n\n"
            + "For docs, license, tests, and downloads, see: http://javadev.github.io/underscore-java";
        System.out.println(message);
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy