com.landawn.abacus.util.Fn Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of abacus-common Show documentation
A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.
There is a newer version: 5.2.4
/*
 * Copyright (c) 2017, Haiyang Li.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.landawn.abacus.util;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.AbstractCollection;
import java.util.AbstractList;
import java.util.AbstractMap;
import java.util.AbstractQueue;
import java.util.AbstractSet;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.Timer;
import java.util.TimerTask;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Pattern;

import com.landawn.abacus.annotation.Beta;
import com.landawn.abacus.annotation.SequentialOnly;
import com.landawn.abacus.annotation.Stateful;
import com.landawn.abacus.util.NoCachingNoUpdating.DisposableArray;
import com.landawn.abacus.util.NoCachingNoUpdating.DisposableObjArray;
import com.landawn.abacus.util.Tuple.Tuple1;
import com.landawn.abacus.util.Tuple.Tuple2;
import com.landawn.abacus.util.Tuple.Tuple3;
import com.landawn.abacus.util.Tuple.Tuple4;
import com.landawn.abacus.util.u.Optional;
import com.landawn.abacus.util.u.OptionalBoolean;
import com.landawn.abacus.util.u.OptionalByte;
import com.landawn.abacus.util.u.OptionalChar;
import com.landawn.abacus.util.u.OptionalDouble;
import com.landawn.abacus.util.u.OptionalFloat;
import com.landawn.abacus.util.u.OptionalInt;
import com.landawn.abacus.util.u.OptionalLong;
import com.landawn.abacus.util.u.OptionalShort;
import com.landawn.abacus.util.function.BiConsumer;
import com.landawn.abacus.util.function.BiFunction;
import com.landawn.abacus.util.function.BiPredicate;
import com.landawn.abacus.util.function.BinaryOperator;
import com.landawn.abacus.util.function.BooleanSupplier;
import com.landawn.abacus.util.function.ByteBiFunction;
import com.landawn.abacus.util.function.ByteBiPredicate;
import com.landawn.abacus.util.function.ByteBinaryOperator;
import com.landawn.abacus.util.function.ByteConsumer;
import com.landawn.abacus.util.function.ByteFunction;
import com.landawn.abacus.util.function.BytePredicate;
import com.landawn.abacus.util.function.Callable;
import com.landawn.abacus.util.function.CharBiFunction;
import com.landawn.abacus.util.function.CharBiPredicate;
import com.landawn.abacus.util.function.CharBinaryOperator;
import com.landawn.abacus.util.function.CharConsumer;
import com.landawn.abacus.util.function.CharFunction;
import com.landawn.abacus.util.function.CharPredicate;
import com.landawn.abacus.util.function.Consumer;
import com.landawn.abacus.util.function.DoubleBiFunction;
import com.landawn.abacus.util.function.DoubleBiPredicate;
import com.landawn.abacus.util.function.DoubleBinaryOperator;
import com.landawn.abacus.util.function.DoubleConsumer;
import com.landawn.abacus.util.function.DoubleFunction;
import com.landawn.abacus.util.function.DoublePredicate;
import com.landawn.abacus.util.function.FloatBiFunction;
import com.landawn.abacus.util.function.FloatBiPredicate;
import com.landawn.abacus.util.function.FloatBinaryOperator;
import com.landawn.abacus.util.function.FloatConsumer;
import com.landawn.abacus.util.function.FloatFunction;
import com.landawn.abacus.util.function.FloatPredicate;
import com.landawn.abacus.util.function.Function;
import com.landawn.abacus.util.function.IndexedBiConsumer;
import com.landawn.abacus.util.function.IndexedBiFunction;
import com.landawn.abacus.util.function.IndexedBiPredicate;
import com.landawn.abacus.util.function.IndexedConsumer;
import com.landawn.abacus.util.function.IndexedFunction;
import com.landawn.abacus.util.function.IndexedPredicate;
import com.landawn.abacus.util.function.IntBiFunction;
import com.landawn.abacus.util.function.IntBiPredicate;
import com.landawn.abacus.util.function.IntBinaryOperator;
import com.landawn.abacus.util.function.IntConsumer;
import com.landawn.abacus.util.function.IntFunction;
import com.landawn.abacus.util.function.IntPredicate;
import com.landawn.abacus.util.function.LongBiFunction;
import com.landawn.abacus.util.function.LongBiPredicate;
import com.landawn.abacus.util.function.LongBinaryOperator;
import com.landawn.abacus.util.function.LongConsumer;
import com.landawn.abacus.util.function.LongFunction;
import com.landawn.abacus.util.function.LongPredicate;
import com.landawn.abacus.util.function.LongSupplier;
import com.landawn.abacus.util.function.Predicate;
import com.landawn.abacus.util.function.QuadFunction;
import com.landawn.abacus.util.function.Runnable;
import com.landawn.abacus.util.function.ShortBiFunction;
import com.landawn.abacus.util.function.ShortBiPredicate;
import com.landawn.abacus.util.function.ShortBinaryOperator;
import com.landawn.abacus.util.function.ShortConsumer;
import com.landawn.abacus.util.function.ShortFunction;
import com.landawn.abacus.util.function.ShortPredicate;
import com.landawn.abacus.util.function.Supplier;
import com.landawn.abacus.util.function.ToBooleanFunction;
import com.landawn.abacus.util.function.ToByteFunction;
import com.landawn.abacus.util.function.ToCharFunction;
import com.landawn.abacus.util.function.ToDoubleFunction;
import com.landawn.abacus.util.function.ToFloatFunction;
import com.landawn.abacus.util.function.ToIntFunction;
import com.landawn.abacus.util.function.ToLongFunction;
import com.landawn.abacus.util.function.ToShortFunction;
import com.landawn.abacus.util.function.TriConsumer;
import com.landawn.abacus.util.function.TriFunction;
import com.landawn.abacus.util.function.TriPredicate;
import com.landawn.abacus.util.function.UnaryOperator;

/**
 * Factory utility class for functional interfaces.
 *
 * 

 * Note: Don't save and reuse any Function/Predicat/Consumer/... created by calling the methods in this class.
 * The method should be called every time.
 * 

 *
 *  * 
 *
 * Map map = N.asMap("a", 1, "b", 2, "c", 3);
 * // Instead of
 * Stream.of(map).filter(e -> e.getKey().equals("a") || e.getKey().equals("b")).toMap(e -> e.getKey(), e -> e.getValue());
 * // Using Fn
 * Stream.of(map).filter(Fn.testByKey(k -> k.equals("a") || k.equals("b"))).collect(Collectors.toMap());
 *
 * 
 * 
 *
 *
 *
 * @author haiyang li
 *
 */

@SuppressWarnings({ "java:S1192", "java:S1221", "java:S1452", "java:S2445" })
public final class Fn extends Comparators {

    private static final Object NONE = new Object();

    private static final Timer timer = new Timer();

    @SuppressWarnings("rawtypes")
    public static final IntFunction> FACTORY_OF_MAP = (IntFunction) Factory.MAP_FACTORY;

    @SuppressWarnings("rawtypes")
    public static final IntFunction> FACTORY_OF_LINKED_HASH_MAP = (IntFunction) Factory.LINKED_HASH_MAP_FACTORY;

    @SuppressWarnings("rawtypes")
    public static final Supplier> SUPPLIER_OF_MAP = (Supplier) Suppliers.MAP;

    @SuppressWarnings("rawtypes")
    public static final Supplier> SUPPLIER_OF_LINKED_HASH_MAP = (Supplier) Suppliers.LINKED_HASH_MAP;

    private static final Runnable EMPTY_ACTION = () -> {
    };

    @SuppressWarnings("rawtypes")
    private static final Consumer DO_NOTHING = value -> {
        // do nothing.
    };

    private static final Consumer CLOSE = IOUtil::close;

    private static final Consumer CLOSE_QUIETLY = IOUtil::closeQuietly;

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_EQUAL = (key, value) -> N.println(Strings.concat(N.toString(key), "=", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_HYPHEN = (key, value) -> N.println(Strings.concat(N.toString(key), "-", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_UNDERSCORE = (key, value) -> N.println(Strings.concat(N.toString(key), "_", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_COLON = (key, value) -> N.println(Strings.concat(N.toString(key), ":", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_COLON_SPACE = (key, value) -> N.println(Strings.concat(N.toString(key), ": ", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_COMMA = (key, value) -> N.println(Strings.concat(N.toString(key), ",", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_COMMA_SPACE = (key, value) -> N.println(Strings.concat(N.toString(key), ", ", N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final BiConsumer PRINTLN_EMPTY = (key, value) -> N.println(Strings.concat(N.toString(key), N.toString(value)));

    @SuppressWarnings("rawtypes")
    private static final Consumer PRINTLN = N::println;

    @SuppressWarnings("rawtypes")
    private static final Function TO_STRING = N::toString;

    private static final Function TO_CAMEL_CASE = Strings::toCamelCase;

    private static final Function TO_LOWER_CASE = Strings::toLowerCase;

    private static final Function TO_LOWER_CASE_WITH_UNDERSCORE = Strings::toLowerCaseWithUnderscore;

    private static final Function TO_UPPER_CASE = Strings::toUpperCase;

    private static final Function TO_UPPER_CASE_WITH_UNDERSCORE = Strings::toUpperCaseWithUnderscore;

    private static final Function TO_RUNTIME_EXCEPTION = ExceptionUtil::toRuntimeException;

    @SuppressWarnings("rawtypes")
    private static final BiFunction COMPARE = N::compare;

    @SuppressWarnings("rawtypes")
    private static final Function IDENTITY = t -> t;

    private static final Function TRIM = t -> t == null ? null : t.trim();

    private static final Function TRIM_TO_EMPTY = t -> t == null ? "" : t.trim();

    private static final Function TRIM_TO_NULL = t -> {
        if (t == null || (t = t.trim()).length() == 0) {
            return null;
        }

        return t;
    };

    private static final Function STRIP = Strings::strip;

    private static final Function STRIP_TO_EMPTY = Strings::stripToEmpty;

    private static final Function STRIP_TO_NULL = Strings::stripToNull;

    private static final Function NULL_TO_EMPTY = t -> t == null ? N.EMPTY_STRING : t;

    @SuppressWarnings("rawtypes")
    private static final Function NULL_TO_EMPTY_LIST = t -> t == null ? N.emptyList() : t;

    @SuppressWarnings("rawtypes")
    private static final Function NULL_TO_EMPTY_SET = t -> t == null ? N.emptySet() : t;

    @SuppressWarnings("rawtypes")
    private static final Function NULL_TO_EMPTY_MAP = t -> t == null ? N.emptyMap() : t;

    private static final Function LENGTH = t -> t == null ? 0 : t.length();

    private static final Function LEN = t -> t == null ? 0 : t.length;

    @SuppressWarnings("rawtypes")
    private static final Function SIZE = t -> t == null ? 0 : t.size();

    @SuppressWarnings("rawtypes")
    private static final Function SIZE_MAP = t -> t == null ? 0 : t.size();

    private static final Function, Object> KEY = Entry::getKey;

    private static final Function, Object> VALUE = Entry::getValue;

    private static final Function, Object> LEFT = Pair::getLeft;

    private static final Function, Object> RIGHT = Pair::getRight;

    private static final Function, Map.Entry> INVERSE = t -> new ImmutableEntry<>(t.getValue(), t.getKey());

    private static final BiFunction> ENTRY = ImmutableEntry::new;

    private static final BiFunction> PAIR = Pair::of;

    private static final TriFunction> TRIPLE = Triple::of;

    private static final Function> TUPLE_1 = Tuple::of;

    private static final BiFunction> TUPLE_2 = Tuple::of;

    private static final TriFunction> TUPLE_3 = Tuple::of;

    private static final QuadFunction> TUPLE_4 = Tuple::of;

    @SuppressWarnings("rawtypes")
    private static final Predicate ALWAYS_TRUE = value -> true;

    @SuppressWarnings("rawtypes")
    private static final Predicate ALWAYS_FALSE = value -> false;

    @SuppressWarnings("rawtypes")
    private static final Predicate IS_NULL = Objects::isNull;

    private static final Predicate IS_NULL_OR_EMPTY = N::isNullOrEmpty;

    private static final Predicate IS_NULL_OR_EMPTY_OR_BLANK = N::isBlank;

    @SuppressWarnings("rawtypes")
    private static final Predicate NOT_NULL = Objects::nonNull;

    private static final Predicate NOT_NULL_OR_EMPTY = N::notNullOrEmpty;

    private static final Predicate NOT_NULL_OR_EMPTY_OR_BLANK = N::notBlank;

    private static final Predicate IS_FILE = file -> file != null && file.isFile();

    private static final Predicate IS_DIRECTORY = file -> file != null && file.isDirectory();

    public static final ToBooleanFunction GET_AS_BOOLEAN = OptionalBoolean::get;

    public static final ToCharFunction GET_AS_CHAR = OptionalChar::get;

    public static final ToByteFunction GET_AS_BYTE = OptionalByte::get;

    public static final ToShortFunction GET_AS_SHORT = OptionalShort::get;

    public static final ToIntFunction GET_AS_INT = OptionalInt::get;

    public static final ToLongFunction GET_AS_LONG = OptionalLong::get;

    public static final ToFloatFunction GET_AS_FLOAT = OptionalFloat::get;

    public static final ToDoubleFunction GET_AS_DOUBLE = OptionalDouble::get;

    public static final ToIntFunction GET_AS_INT_JDK = java.util.OptionalInt::getAsInt;

    public static final ToLongFunction GET_AS_LONG_JDK = java.util.OptionalLong::getAsLong;

    public static final ToDoubleFunction GET_AS_DOUBLE_JDK = java.util.OptionalDouble::getAsDouble;

    public static final Predicate IS_PRESENT_BOOLEAN = OptionalBoolean::isPresent;

    public static final Predicate IS_PRESENT_CHAR = OptionalChar::isPresent;

    public static final Predicate IS_PRESENT_BYTE = OptionalByte::isPresent;

    public static final Predicate IS_PRESENT_SHORT = OptionalShort::isPresent;

    public static final Predicate IS_PRESENT_INT = OptionalInt::isPresent;

    public static final Predicate IS_PRESENT_LONG = OptionalLong::isPresent;

    public static final Predicate IS_PRESENT_FLOAT = OptionalFloat::isPresent;

    public static final Predicate IS_PRESENT_DOUBLE = OptionalDouble::isPresent;

    public static final Predicate IS_PRESENT_INT_JDK = java.util.OptionalInt::isPresent;

    public static final Predicate IS_PRESENT_LONG_JDK = java.util.OptionalLong::isPresent;

    public static final Predicate IS_PRESENT_DOUBLE_JDK = java.util.OptionalDouble::isPresent;

    protected Fn() {
        // for extension.
    }

    /**
     *
     * @param 
     * @param supplier
     * @return
     */
    public static  T get(final java.util.function.Supplier supplier) {
        return supplier.get();
    }

    /**
     * Returns a {@code Supplier} which returns a single instance created by calling the specified {@code supplier.get()}.
     *
     * @param 
     * @param supplier
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Supplier memoize(final java.util.function.Supplier supplier) {
        return LazyInitializer.of(supplier);
    }

    //    /**
    //     *
    //     * @param 
    //     * @param 
    //     * @param func
    //     * @return
    //     */
    //    @Beta
    //    @SequentialOnly
    //    @Stateful
    //    public static  IntFunction memoize(final IntFunction func) {
    //        return new IntFunction() {
    //            private volatile R resultForNull = (R) NONE;
    //
    //            @Override
    //            public R apply(int t) {
    //                R result = resultForNull;
    //
    //                if (result == NONE) {
    //                    synchronized (this) {
    //                        if (resultForNull == NONE) {
    //                            resultForNull = func.apply(t);
    //                        }
    //
    //                        result = resultForNull;
    //                    }
    //                }
    //
    //                return result;
    //            }
    //        };
    //    }

    /**
     *
     * @param 
     * @param 
     * @param func
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Function memoize(final java.util.function.Function func) {
        return new Function<>() {
            private volatile R resultForNull = (R) NONE; //NOSONAR
            private volatile Map resultMap = null; //NOSONAR

            @Override
            public R apply(T t) {
                R result = null;

                if (t == null) {
                    result = resultForNull;

                    if (result == NONE) {
                        synchronized (this) {
                            if (resultForNull == NONE) {
                                resultForNull = func.apply(t);
                            }

                            result = resultForNull;
                        }
                    }
                } else {
                    synchronized (this) {
                        if (resultMap == null) {
                            resultMap = new HashMap<>();
                        }

                        result = resultMap.get(t);

                        if (result == null && !resultMap.containsKey(t)) {
                            result = func.apply(t);
                            resultMap.put(t, result);
                        }
                    }
                }

                return result;
            }
        };
    }

    /**
     * Only for temporary use in sequential stream/single thread, not for parallel stream/multiple threads.
     * The returned Collection will clean up before it's returned every time when {@code get} is called.
     * Don't save the returned Collection object or use it to save objects.
     *
     * @param 
     * @param 
     * @param supplier
     * @return
     * @see {@code Stream.split/sliding};
     * @deprecated
     */
    @Deprecated
    @Beta
    @SequentialOnly
    @Stateful
    public static > Supplier reuse(final java.util.function.Supplier supplier) {
        return new Supplier() {
            private C c;

            @Override
            public C get() {
                if (c == null) {
                    c = supplier.get();
                } else if (c.size() > 0) {
                    c.clear();
                }

                return c;
            }
        };
    }

    /**
     * Only for temporary use in sequential stream/single thread, not for parallel stream/multiple threads.
     * The returned Collection will clean up before it's returned every time when {@code get} is called.
     * Don't save the returned Collection object or use it to save objects.
     *
     * @param 
     * @param 
     * @param supplier
     * @return
     * @see {@code Stream.split/sliding};
     * @deprecated
     */
    @Deprecated
    @Beta
    @SequentialOnly
    @Stateful
    public static > IntFunction reuse(final java.util.function.IntFunction supplier) {
        return new IntFunction() {
            private C c;

            @Override
            public C apply(int size) {
                if (c == null) {
                    c = supplier.apply(size);
                } else if (c.size() > 0) {
                    c.clear();
                }

                return c;
            }
        };
    }

    /**
     *
     * @param closeable
     * @return
     */
    public static Runnable close(final AutoCloseable closeable) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                IOUtil.close(closeable);
            }
        };
    }

    /**
     *
     * @param a
     * @return
     */
    @SafeVarargs
    public static Runnable closeAll(final AutoCloseable... a) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                IOUtil.closeAll(a);
            }
        };
    }

    /**
     *
     * @param c
     * @return
     */
    public static Runnable closeAll(final Collection c) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                IOUtil.closeAll(c);
            }
        };
    }

    /**
     *
     * @param closeable
     * @return
     */
    public static Runnable closeQuietly(final AutoCloseable closeable) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                IOUtil.closeQuietly(closeable);
            }
        };
    }

    /**
     * Close all quietly.
     *
     * @param a
     * @return
     */
    @SafeVarargs
    public static Runnable closeAllQuietly(final AutoCloseable... a) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                IOUtil.closeAllQuietly(a);
            }
        };
    }

    /**
     * Close all quietly.
     *
     * @param c
     * @return
     */
    public static Runnable closeAllQuietly(final Collection c) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                IOUtil.closeAllQuietly(c);
            }
        };
    }

    /**
     *
     *
     * @return
     */
    public static Runnable emptyAction() {
        return EMPTY_ACTION;
    }

    /**
     *
     *
     * @param service
     * @return
     */
    public static Runnable shutDown(final ExecutorService service) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                service.shutdown();
            }
        };
    }

    /**
     *
     *
     * @param service
     * @param terminationTimeout
     * @param timeUnit
     * @return
     */
    public static Runnable shutDown(final ExecutorService service, final long terminationTimeout, final TimeUnit timeUnit) {
        return new Runnable() {
            private volatile boolean isClosed = false;

            @Override
            public void run() {
                if (isClosed) {
                    return;
                }

                isClosed = true;
                try {
                    service.shutdown();
                    service.awaitTermination(terminationTimeout, timeUnit);
                } catch (InterruptedException e) {
                    // ignore.
                }
            }
        };
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Consumer doNothing() {
        return DO_NOTHING;
    }

    /**
     *
     * @param 
     * @param errorMessage
     * @return
     */
    public static  Consumer throwRuntimeException(final String errorMessage) {
        return t -> {
            throw new RuntimeException(errorMessage);
        };
    }

    /**
     *
     * @param 
     * @param excpetionSupplier
     * @return
     */
    public static  Consumer throwException(final java.util.function.Supplier excpetionSupplier) {
        return t -> {
            throw excpetionSupplier.get();
        };
    }

    /**
     *
     *
     * @return
     */
    public static Function toRuntimeException() {
        return TO_RUNTIME_EXCEPTION;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Consumer close() {
        return (Consumer) CLOSE;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Consumer closeQuietly() {
        return (Consumer) CLOSE_QUIETLY;
    }

    /**
     *
     * @param 
     * @param millis
     * @return
     */
    public static  Consumer sleep(final long millis) {
        return t -> N.sleep(millis);
    }

    /**
     *
     * @param 
     * @param millis
     * @return
     */
    public static  Consumer sleepUninterruptibly(final long millis) {
        return t -> N.sleepUninterruptibly(millis);
    }

    /**
     * Returns a stateful Consumer. Don't save or cache for reuse
     *
     * @param 
     * @param permitsPerSecond
     * @return
     * @see RateLimiter#acquire()
     * @see RateLimiter#create(double)
     */
    @Stateful
    public static  Consumer rateLimiter(final double permitsPerSecond) {
        return rateLimiter(RateLimiter.create(permitsPerSecond));
    }

    /**
     * Returns a stateful Consumer. Don't save or cache for reuse
     *
     * @param 
     * @param rateLimiter
     * @return
     * @see RateLimiter#acquire()
     */
    @Stateful
    public static  Consumer rateLimiter(final RateLimiter rateLimiter) {
        return t -> rateLimiter.acquire();
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Consumer println() {
        return PRINTLN;
    }

    /**
     *
     * @param 
     * @param 
     * @param separator
     * @return
     */
    public static  BiConsumer println(final String separator) {
        N.checkArgNotNull(separator);

        switch (separator) {
            case "=":
                return PRINTLN_EQUAL;

            case ":":
                return PRINTLN_COLON;

            case ": ":
                return PRINTLN_COLON_SPACE;

            case "-":
                return PRINTLN_HYPHEN;

            case "_":
                return PRINTLN_UNDERSCORE;

            case ",":
                return PRINTLN_COMMA;

            case ", ":
                return PRINTLN_COMMA_SPACE;

            case "":
                return PRINTLN_EMPTY;

            default:
                return (t, u) -> N.println(t + separator + u);
        }
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Function toStr() {
        return TO_STRING;
    }

    /**
     * To camel case.
     *
     * @return
     */
    public static Function toCamelCase() {
        return TO_CAMEL_CASE;
    }

    /**
     * To lower case.
     *
     * @return
     */
    public static Function toLowerCase() {
        return TO_LOWER_CASE;
    }

    /**
     * To lower case with underscore.
     *
     * @return
     */
    public static Function toLowerCaseWithUnderscore() {
        return TO_LOWER_CASE_WITH_UNDERSCORE;
    }

    /**
     * To upper case.
     *
     * @return
     */
    public static Function toUpperCase() {
        return TO_UPPER_CASE;
    }

    /**
     * To upper case with underscore.
     *
     * @return
     */
    public static Function toUpperCaseWithUnderscore() {
        return TO_UPPER_CASE_WITH_UNDERSCORE;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Function identity() {
        return IDENTITY;
    }

    /**
     *
     * @param  the key type
     * @param 
     * @param keyMapper
     * @return
     */
    public static  Function> keyed(final java.util.function.Function keyMapper) {
        N.checkArgNotNull(keyMapper);

        return t -> Keyed.of(keyMapper.apply(t), t);
    }

    private static final Function, Object> VAL = Keyed::val;

    private static final Function, Object>, Object> KK_VAL = t -> t.getKey().val();

    /**
     *
     * @param  the key type
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, T> val() {
        return (Function) VAL;
    }

    /**
     *
     * @param 
     * @param  the key type
     * @param  the value type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, V>, T> kkv() {
        return (Function) KK_VAL;
    }

    private static final Function> WRAP = Wrapper::of;

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function> wrap() {
        return (Function) WRAP;
    }

    /**
     *
     * @param 
     * @param hashFunction
     * @param equalsFunction
     * @return
     */
    public static  Function> wrap(final java.util.function.ToIntFunction hashFunction,
            final java.util.function.BiPredicate equalsFunction) {
        N.checkArgNotNull(hashFunction);
        N.checkArgNotNull(equalsFunction);

        return t -> Wrapper.of(t, hashFunction, equalsFunction);
    }

    private static final Function, Object> UNWRAP = Wrapper::value;

    /**
     *
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, T> unwrap() {
        return (Function) UNWRAP;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, K> key() {
        return (Function) KEY;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, V> value() {
        return (Function) VALUE;
    }

    /**
     *
     *
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, L> left() {
        return (Function) LEFT;
    }

    /**
     *
     *
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, R> right() {
        return (Function) RIGHT;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, Entry> inverse() {
        return (Function) INVERSE;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  BiFunction> entry() {
        return (BiFunction) ENTRY;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param key
     * @return
     * @deprecated replaced by {@code Fn#entryWithKey(Object)}
     */
    @Deprecated
    public static  Function> entry(final K key) {
        return entryWithKey(key);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param keyMapper
     * @return
     * @deprecated replaced by {@code Fn#entryByKeyMapper(Function)}
     */
    @Deprecated
    public static  Function> entry(final java.util.function.Function keyMapper) {
        return entryByKeyMapper(keyMapper);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param key
     * @return
     */
    public static  Function> entryWithKey(final K key) {
        return v -> new ImmutableEntry<>(key, v);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param keyMapper
     * @return
     */
    public static  Function> entryByKeyMapper(final java.util.function.Function keyMapper) {
        N.checkArgNotNull(keyMapper);

        return v -> new ImmutableEntry<>(keyMapper.apply(v), v);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param value
     * @return
     */
    public static  Function> entryWithValue(final V value) {
        return k -> new ImmutableEntry<>(k, value);
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param valueMapper
     * @return
     */
    public static  Function> entryByValueMapper(final java.util.function.Function valueMapper) {
        N.checkArgNotNull(valueMapper);

        return k -> new ImmutableEntry<>(k, valueMapper.apply(k));
    }

    /**
     *
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  BiFunction> pair() {
        return (BiFunction) PAIR;
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  TriFunction> triple() {
        return (TriFunction) TRIPLE;
    }

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function> tuple1() {
        return (Function) TUPLE_1;
    }

    /**
     *
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  BiFunction> tuple2() {
        return (BiFunction) TUPLE_2;
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  TriFunction> tuple3() {
        return (TriFunction) TUPLE_3;
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @return
     */
    @SuppressWarnings({ "rawtypes" })
    public static  QuadFunction> tuple4() {
        return (QuadFunction) TUPLE_4;
    }

    /**
     *
     *
     * @return
     */
    public static Function trim() {
        return TRIM;
    }

    /**
     *
     *
     * @return
     */
    public static Function trimToEmpty() {
        return TRIM_TO_EMPTY;
    }

    /**
     *
     *
     * @return
     */
    public static Function trimToNull() {
        return TRIM_TO_NULL;
    }

    /**
     *
     *
     * @return
     */
    public static Function strip() {
        return STRIP;
    }

    /**
     *
     *
     * @return
     */
    public static Function stripToEmpty() {
        return STRIP_TO_EMPTY;
    }

    /**
     *
     *
     * @return
     */
    public static Function stripToNull() {
        return STRIP_TO_NULL;
    }

    /**
     *
     *
     * @return
     */
    public static Function nullToEmpty() {
        return NULL_TO_EMPTY;
    }

    /**
     *
     * @param 
     * @return
     * @deprecated replaced by {@code nullToEmptyList}
     */
    @Deprecated
    @SuppressWarnings("rawtypes")
    public static  Function, List> nullToEmptyL() {
        return (Function) NULL_TO_EMPTY_LIST;
    }

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, List> nullToEmptyList() {
        return (Function) NULL_TO_EMPTY_LIST;
    }

    /**
     *
     * @param 
     * @return
     * @deprecated replaced by {@code nullToEmptySet}
     */
    @Deprecated
    @SuppressWarnings("rawtypes")
    public static  Function, Set> nullToEmptyS() {
        return (Function) NULL_TO_EMPTY_SET;
    }

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, Set> nullToEmptySet() {
        return (Function) NULL_TO_EMPTY_SET;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @return
     * @deprecated replaced by {@code nullToEmptyMap}
     */
    @Deprecated
    @SuppressWarnings("rawtypes")
    public static  Function, Map> nullToEmptyM() {
        return (Function) NULL_TO_EMPTY_MAP;
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function, Map> nullToEmptyMap() {
        return (Function) NULL_TO_EMPTY_MAP;
    }

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function len() {
        return (Function) LEN;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Function length() {
        return (Function) LENGTH;
    }

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function size() {
        return (Function) SIZE;
    }

    /**
     *
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static  Function sizeM() {
        return (Function) SIZE_MAP;
    }

    /**
     *
     * @param 
     * @param 
     * @param clazz
     * @return
     */
    public static  Function cast(final Class clazz) {
        N.checkArgNotNull(clazz);

        return t -> (U) t;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Predicate alwaysTrue() {
        return ALWAYS_TRUE;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Predicate alwaysFalse() {
        return ALWAYS_FALSE;
    }

    /**
     * Checks if is null.
     *
     * @param 
     * @return
     */
    public static  Predicate isNull() {
        return IS_NULL;
    }

    /**
     * Checks if is null.
     *
     * @param 
     * @param valueExtractor
     * @return
     */
    public static  Predicate isNull(final java.util.function.Function valueExtractor) {
        return t -> valueExtractor.apply(t) == null;
    }

    /**
     * Checks if is null or empty.
     *
     * @param 
     * @return
     */
    public static  Predicate isNullOrEmpty() {
        return (Predicate) IS_NULL_OR_EMPTY;
    }

    /**
     *
     * @param 
     * @param valueExtractor
     * @return
     */
    public static  Predicate isNullOrEmpty(final java.util.function.Function valueExtractor) {
        return t -> N.isNullOrEmpty(valueExtractor.apply(t));
    }

    /**
     * Checks if is null or empty or blank.
     *
     * @param 
     * @return
     */
    public static  Predicate isBlank() {
        return (Predicate) IS_NULL_OR_EMPTY_OR_BLANK;
    }

    /**
     *
     * @param 
     * @param valueExtractor
     * @return
     */
    public static  Predicate isBlank(final java.util.function.Function valueExtractor) {
        return t -> N.isBlank(valueExtractor.apply(t));
    }

    private static final Predicate IS_NULL_OR_EMPTY_A = value -> value == null || value.length == 0;

    /**
     *
     *
     * @param 
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static  Predicate isNullOrEmptyA() {
        return (Predicate) IS_NULL_OR_EMPTY_A;
    }

    @SuppressWarnings("rawtypes")
    private static final Predicate IS_NULL_OR_EMPTY_C = value -> value == null || value.size() == 0;

    /**
     *
     *
     * @param 
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static  Predicate isNullOrEmptyC() {
        return (Predicate) IS_NULL_OR_EMPTY_C;
    }

    @SuppressWarnings("rawtypes")
    private static final Predicate IS_NULL_OR_EMPTY_M = value -> value == null || value.size() == 0;

    /**
     *
     *
     * @param 
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static  Predicate isNullOrEmptyM() {
        return (Predicate) IS_NULL_OR_EMPTY_M;
    }

    /**
     *
     * @param 
     * @return
     */
    public static  Predicate notNull() {
        return NOT_NULL;
    }

    /**
     * Not null.
     *
     * @param 
     * @param valueExtractor
     * @return
     */
    public static  Predicate notNull(final java.util.function.Function valueExtractor) {
        return t -> valueExtractor.apply(t) != null;
    }

    /**
     * Not null or empty.
     *
     * @param 
     * @return
     */
    public static  Predicate notNullOrEmpty() {
        return (Predicate) NOT_NULL_OR_EMPTY;
    }

    /**
     *
     * @param 
     * @param valueExtractor
     * @return
     */
    public static  Predicate notNullOrEmpty(final java.util.function.Function valueExtractor) {
        return t -> N.notNullOrEmpty(valueExtractor.apply(t));
    }

    /**
     * Not null or empty or blank.
     *
     * @param 
     * @return
     */
    public static  Predicate notBlank() {
        return (Predicate) NOT_NULL_OR_EMPTY_OR_BLANK;
    }

    /**
     *
     * @param 
     * @param valueExtractor
     * @return
     */
    public static  Predicate notBlank(final java.util.function.Function valueExtractor) {
        return t -> N.notBlank(valueExtractor.apply(t));
    }

    private static final Predicate NOT_NULL_OR_EMPTY_A = value -> value != null && value.length > 0;

    /**
     *
     *
     * @param 
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static  Predicate notNullOrEmptyA() {
        return (Predicate) NOT_NULL_OR_EMPTY_A;
    }

    @SuppressWarnings("rawtypes")
    private static final Predicate NOT_NULL_OR_EMPTY_C = value -> value != null && value.size() > 0;

    /**
     *
     *
     * @param 
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static  Predicate notNullOrEmptyC() {
        return (Predicate) NOT_NULL_OR_EMPTY_C;
    }

    @SuppressWarnings("rawtypes")
    private static final Predicate NOT_NULL_OR_EMPTY_M = value -> value != null && value.size() > 0;

    /**
     *
     *
     * @param 
     * @return
     */
    @Beta
    @SuppressWarnings("rawtypes")
    public static  Predicate notNullOrEmptyM() {
        return (Predicate) NOT_NULL_OR_EMPTY_M;
    }

    /**
     * Checks if is file.
     *
     * @return
     */
    public static Predicate isFile() {
        return IS_FILE;
    }

    /**
     * Checks if is directory.
     *
     * @return
     */
    public static Predicate isDirectory() {
        return IS_DIRECTORY;
    }

    /**
     *
     * @param 
     * @param target
     * @return
     */
    public static  Predicate equal(final Object target) {
        return value -> N.equals(value, target);
    }

    /**
     *
     * @param 
     * @param targetValue1
     * @param targetValue2
     * @return
     */
    public static  Predicate eqOr(final Object targetValue1, final Object targetValue2) {
        return value -> N.equals(value, targetValue1) || N.equals(value, targetValue2);
    }

    /**
     *
     * @param 
     * @param targetValue1
     * @param targetValue2
     * @param targetValue3
     * @return
     */
    public static  Predicate eqOr(final Object targetValue1, final Object targetValue2, final Object targetValue3) {
        return value -> N.equals(value, targetValue1) || N.equals(value, targetValue2) || N.equals(value, targetValue3);
    }

    /**
     *
     * @param 
     * @param target
     * @return
     */
    public static  Predicate notEqual(final Object target) {
        return value -> !N.equals(value, target);
    }

    /**
     *
     * @param 
     * @param target
     * @return
     */
    public static > Predicate greaterThan(final T target) {
        return value -> N.compare(value, target) > 0;
    }

    /**
     *
     * @param 
     * @param target
     * @return
     */
    public static > Predicate greaterEqual(final T target) {
        return value -> N.compare(value, target) >= 0;
    }

    /**
     *
     * @param 
     * @param target
     * @return
     */
    public static > Predicate lessThan(final T target) {
        return value -> N.compare(value, target) < 0;
    }

    /**
     *
     * @param 
     * @param target
     * @return
     */
    public static > Predicate lessEqual(final T target) {
        return value -> N.compare(value, target) <= 0;
    }

    /**
     * Checks if the value/element: {@code minValue < e < maxValue}.
     *
     * @param 
     * @param minValue
     * @param maxValue
     * @return
     */
    public static > Predicate gtAndLt(final T minValue, final T maxValue) {
        return value -> N.compare(value, minValue) > 0 && N.compare(value, maxValue) < 0;
    }

    /**
     * Checks if the value/element: {@code minValue <= e < maxValue}.
     *
     * @param 
     * @param minValue
     * @param maxValue
     * @return
     */
    public static > Predicate geAndLt(final T minValue, final T maxValue) {
        return value -> N.compare(value, minValue) >= 0 && N.compare(value, maxValue) < 0;
    }

    /**
     * Checks if the value/element: {@code minValue <= e <= maxValue}.
     *
     * @param 
     * @param minValue
     * @param maxValue
     * @return
     */
    public static > Predicate geAndLe(final T minValue, final T maxValue) {
        return value -> N.compare(value, minValue) >= 0 && N.compare(value, maxValue) <= 0;
    }

    /**
     * Checks if the value/element: {@code minValue < e <= maxValue}.
     *
     * @param 
     * @param minValue
     * @param maxValue
     * @return
     */
    public static > Predicate gtAndLe(final T minValue, final T maxValue) {
        return value -> N.compare(value, minValue) > 0 && N.compare(value, maxValue) <= 0;
    }

    /**
     * Checks if the value/element: {@code minValue < e < maxValue}.
     *
     * @param 
     * @param minValue
     * @param maxValue
     * @return
     * @deprecated replaced by {@code gtAndLt}.
     */
    @Deprecated
    public static > Predicate between(final T minValue, final T maxValue) {
        return value -> N.compare(value, minValue) > 0 && N.compare(value, maxValue) < 0;
    }

    /**
     *
     * @param 
     * @param c
     * @return
     */
    public static  Predicate in(final Collection c) {
        N.checkArgNotNull(c);

        final boolean isNotEmpty = N.notNullOrEmpty(c);

        return value -> isNotEmpty && c.contains(value);
    }

    /**
     *
     * @param 
     * @param c
     * @return
     */
    public static  Predicate notIn(final Collection c) {
        N.checkArgNotNull(c);

        final boolean isEmpty = N.isNullOrEmpty(c);

        return value -> isEmpty || !c.contains(value);
    }

    /**
     *
     * @param 
     * @param clazz
     * @return
     */
    public static  Predicate instanceOf(final Class clazz) {
        N.checkArgNotNull(clazz);

        return value -> value != null && clazz.isInstance(value);
    }

    /**
     *
     * @param clazz
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static Predicate subtypeOf(final Class clazz) {
        N.checkArgNotNull(clazz);

        return clazz::isAssignableFrom;
    }

    /**
     *
     * @param prefix
     * @return
     */
    public static Predicate startsWith(final String prefix) {
        N.checkArgNotNull(prefix);

        return value -> value != null && value.startsWith(prefix);
    }

    /**
     *
     * @param suffix
     * @return
     */
    public static Predicate endsWith(final String suffix) {
        N.checkArgNotNull(suffix);

        return value -> value != null && value.endsWith(suffix);
    }

    /**
     *
     * @param str
     * @return
     */
    public static Predicate contains(final String str) {
        N.checkArgNotNull(str);

        return value -> value != null && value.contains(str);
    }

    /**
     * Not starts with.
     *
     * @param prefix
     * @return
     */
    public static Predicate notStartsWith(final String prefix) {
        N.checkArgNotNull(prefix);

        return value -> value == null || !value.startsWith(prefix);
    }

    /**
     * Not ends with.
     *
     * @param suffix
     * @return
     */
    public static Predicate notEndsWith(final String suffix) {
        N.checkArgNotNull(suffix);

        return value -> value == null || !value.endsWith(suffix);
    }

    /**
     *
     * @param str
     * @return
     */
    public static Predicate notContains(final String str) {
        N.checkArgNotNull(str);

        return value -> value == null || !value.contains(str);
    }

    /**
     *
     * @param pattern
     * @return
     */
    public static Predicate matches(final Pattern pattern) {
        N.checkArgNotNull(pattern);

        return value -> pattern.matcher(value).find();
    }

    /**
     *
     * @param 
     * @param 
     * @return
     */
    public static  BiPredicate equal() {
        return BiPredicates.EQUAL;
    }

    /**
     *
     * @param 
     * @param 
     * @return
     */
    public static  BiPredicate notEqual() {
        return BiPredicates.NOT_EQUAL;
    }

    /**
     *
     * @param 
     * @return
     */
    public static > BiPredicate greaterThan() {
        return (BiPredicate) BiPredicates.GREATER_THAN;
    }

    /**
     *
     * @param 
     * @return
     */
    public static > BiPredicate greaterEqual() {
        return (BiPredicate) BiPredicates.GREATER_EQUAL;
    }

    /**
     *
     * @param 
     * @return
     */
    public static > BiPredicate lessThan() {
        return (BiPredicate) BiPredicates.LESS_THAN;
    }

    /**
     *
     * @param 
     * @return
     */
    public static > BiPredicate lessEqual() {
        return (BiPredicate) BiPredicates.LESS_EQUAL;
    }

    /**
     *
     * @param 
     * @param predicate
     * @return
     */
    public static  Predicate not(final java.util.function.Predicate predicate) {
        N.checkArgNotNull(predicate);

        return t -> !predicate.test(t);
    }

    /**
     *
     * @param 
     * @param 
     * @param biPredicate
     * @return
     */
    public static  BiPredicate not(final java.util.function.BiPredicate biPredicate) {
        N.checkArgNotNull(biPredicate);

        return (t, u) -> !biPredicate.test(t, u);
    }

    /**
     *
     * @param 
     * @param 
     * @param 
     * @param triPredicate
     * @return
     */
    public static  TriPredicate not(final TriPredicate triPredicate) {
        N.checkArgNotNull(triPredicate);

        return (a, b, c) -> !triPredicate.test(a, b, c);
    }

    /**
     *
     * @param first
     * @param second
     * @return
     */
    public static BooleanSupplier and(final java.util.function.BooleanSupplier first, final java.util.function.BooleanSupplier second) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);

        return () -> first.getAsBoolean() && second.getAsBoolean();
    }

    /**
     *
     * @param first
     * @param second
     * @param third
     * @return
     */
    public static BooleanSupplier and(final java.util.function.BooleanSupplier first, final java.util.function.BooleanSupplier second,
            final java.util.function.BooleanSupplier third) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);
        N.checkArgNotNull(third);

        return () -> first.getAsBoolean() && second.getAsBoolean() && third.getAsBoolean();
    }

    /**
     *
     * @param 
     * @param first
     * @param second
     * @return
     */
    public static  Predicate and(final java.util.function.Predicate first, final java.util.function.Predicate second) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);

        return t -> first.test(t) && second.test(t);
    }

    /**
     *
     * @param 
     * @param first
     * @param second
     * @param third
     * @return
     */
    public static  Predicate and(final java.util.function.Predicate first, final java.util.function.Predicate second,
            final java.util.function.Predicate third) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);
        N.checkArgNotNull(third);

        return t -> first.test(t) && second.test(t) && third.test(t);
    }

    /**
     *
     * @param 
     * @param c
     * @return
     * @throws IllegalArgumentException if the specified {@code c} is null or empty.
     */
    public static  Predicate and(final Collection> c) throws IllegalArgumentException {
        N.checkArgNotNullOrEmpty(c, "c");

        return t -> {
            for (java.util.function.Predicate p : c) {
                if (!p.test(t)) {
                    return false;
                }
            }

            return true;
        };
    }

    /**
     *
     * @param 
     * @param 
     * @param first
     * @param second
     * @return
     */
    public static  BiPredicate and(final java.util.function.BiPredicate first,
            final java.util.function.BiPredicate second) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);

        return (t, u) -> first.test(t, u) && second.test(t, u);
    }

    /**
     *
     * @param 
     * @param 
     * @param first
     * @param second
     * @param third
     * @return
     */
    public static  BiPredicate and(final java.util.function.BiPredicate first,
            final java.util.function.BiPredicate second, final BiPredicate third) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);
        N.checkArgNotNull(third);

        return (t, u) -> first.test(t, u) && second.test(t, u) && third.test(t, u);
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @return
     * @throws IllegalArgumentException if the specified {@code c} is null or empty.
     */
    public static  BiPredicate and(final List> c) throws IllegalArgumentException {
        N.checkArgNotNullOrEmpty(c, "c");

        return (t, u) -> {
            for (java.util.function.BiPredicate p : c) {
                if (!p.test(t, u)) {
                    return false;
                }
            }

            return true;
        };
    }

    /**
     *
     * @param first
     * @param second
     * @return
     */
    public static BooleanSupplier or(final java.util.function.BooleanSupplier first, final java.util.function.BooleanSupplier second) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);

        return () -> first.getAsBoolean() || second.getAsBoolean();
    }

    /**
     *
     * @param first
     * @param second
     * @param third
     * @return
     */
    public static BooleanSupplier or(final java.util.function.BooleanSupplier first, final java.util.function.BooleanSupplier second,
            final java.util.function.BooleanSupplier third) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);
        N.checkArgNotNull(third);

        return () -> first.getAsBoolean() || second.getAsBoolean() || third.getAsBoolean();
    }

    /**
     *
     * @param 
     * @param first
     * @param second
     * @return
     */
    public static  Predicate or(final java.util.function.Predicate first, final java.util.function.Predicate second) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);

        return t -> first.test(t) || second.test(t);
    }

    /**
     *
     * @param 
     * @param first
     * @param second
     * @param third
     * @return
     */
    public static  Predicate or(final java.util.function.Predicate first, final java.util.function.Predicate second,
            final java.util.function.Predicate third) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);
        N.checkArgNotNull(third);

        return t -> first.test(t) || second.test(t) || third.test(t);
    }

    /**
     *
     * @param 
     * @param c
     * @return
     * @throws IllegalArgumentException if the specified {@code c} is null or empty.
     */
    public static  Predicate or(final Collection> c) throws IllegalArgumentException {
        N.checkArgNotNullOrEmpty(c, "c");

        return t -> {
            for (java.util.function.Predicate p : c) {
                if (p.test(t)) {
                    return true;
                }
            }

            return false;
        };
    }

    /**
     *
     * @param 
     * @param 
     * @param first
     * @param second
     * @return
     */
    public static  BiPredicate or(final java.util.function.BiPredicate first,
            final java.util.function.BiPredicate second) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);

        return (t, u) -> first.test(t, u) || second.test(t, u);
    }

    /**
     *
     * @param 
     * @param 
     * @param first
     * @param second
     * @param third
     * @return
     */
    public static  BiPredicate or(final java.util.function.BiPredicate first,
            final java.util.function.BiPredicate second, final java.util.function.BiPredicate third) {
        N.checkArgNotNull(first);
        N.checkArgNotNull(second);
        N.checkArgNotNull(third);

        return (t, u) -> first.test(t, u) || second.test(t, u) || third.test(t, u);
    }

    /**
     *
     * @param 
     * @param 
     * @param c
     * @return
     * @throws IllegalArgumentException if the specified {@code c} is null or empty.
     */
    public static  BiPredicate or(final List> c) throws IllegalArgumentException {
        N.checkArgNotNullOrEmpty(c, "c");

        return (t, u) -> {
            for (java.util.function.BiPredicate p : c) {
                if (p.test(t, u)) {
                    return true;
                }
            }

            return false;
        };
    }

    /**
     * Test by key.
     *
     * @param  the key type
     * @param  the value type
     * @param predicate
     * @return
     */
    public static  Predicate> testByKey(final java.util.function.Predicate predicate) {
        N.checkArgNotNull(predicate);

        return entry -> predicate.test(entry.getKey());
    }

    /**
     * Test by value.
     *
     * @param  the key type
     * @param  the value type
     * @param predicate
     * @return
     */
    public static  Predicate> testByValue(final java.util.function.Predicate predicate) {
        N.checkArgNotNull(predicate);

        return entry -> predicate.test(entry.getValue());
    }

    /**
     * Accept by key.
     *
     * @param  the key type
     * @param  the value type
     * @param consumer
     * @return
     */
    public static  Consumer> acceptByKey(final java.util.function.Consumer consumer) {
        N.checkArgNotNull(consumer);

        return entry -> consumer.accept(entry.getKey());
    }

    /**
     * Accept by value.
     *
     * @param  the key type
     * @param  the value type
     * @param consumer
     * @return
     */
    public static  Consumer> acceptByValue(final java.util.function.Consumer consumer) {
        N.checkArgNotNull(consumer);

        return entry -> consumer.accept(entry.getValue());
    }

    /**
     *
     *
     * @param 
     * @param predicate
     * @param consumer
     * @return
     */
    @Beta
    public static  Consumer acceptIf(final java.util.function.Predicate predicate, final java.util.function.Consumer consumer) {
        N.checkArgNotNull(predicate);
        N.checkArgNotNull(consumer);

        return t -> {
            if (predicate.test(t)) {
                consumer.accept(t);
            }
        };
    }

    /**
     *
     *
     * @param 
     * @param predicate
     * @param consumerForTrue
     * @param consumerForFalse
     * @return
     */
    @Beta
    public static  Consumer acceptIfOrElse(final java.util.function.Predicate predicate,
            final java.util.function.Consumer consumerForTrue, final java.util.function.Consumer consumerForFalse) {
        N.checkArgNotNull(predicate);
        N.checkArgNotNull(consumerForTrue);
        N.checkArgNotNull(consumerForFalse);

        return t -> {
            if (predicate.test(t)) {
                consumerForTrue.accept(t);
            } else {
                consumerForFalse.accept(t);
            }
        };
    }

    /**
     * Apply by key.
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param func
     * @return
     */
    public static  Function, R> applyByKey(final java.util.function.Function func) {
        N.checkArgNotNull(func);

        return entry -> func.apply(entry.getKey());
    }

    /**
     * Apply by value.
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param func
     * @return
     */
    public static  Function, R> applyByValue(final java.util.function.Function func) {
        N.checkArgNotNull(func);

        return entry -> func.apply(entry.getValue());
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param predicate
     * @param func
     * @param defaultValue
     * @return
     */
    @Beta
    public static  Function applyIfOrElseDefault(final java.util.function.Predicate predicate,
            final java.util.function.Function func, final R defaultValue) {
        N.checkArgNotNull(predicate);
        N.checkArgNotNull(func);

        return t -> {
            if (predicate.test(t)) {
                return func.apply(t);
            } else {
                return defaultValue;
            }
        };
    }

    /**
     *
     *
     * @param 
     * @param 
     * @param predicate
     * @param func
     * @param supplier
     * @return
     */
    @Beta
    public static  Function applyIfOrElseGet(final java.util.function.Predicate predicate,
            final java.util.function.Function func, final java.util.function.Supplier supplier) {
        N.checkArgNotNull(predicate);
        N.checkArgNotNull(func);
        N.checkArgNotNull(supplier);

        return t -> {
            if (predicate.test(t)) {
                return func.apply(t);
            } else {
                return supplier.get();
            }
        };
    }

    /**
     * Apply if not null or default.
     *
     * @param 
     * @param 
     * @param 
     * @param mapperA
     * @param mapperB
     * @param defaultValue
     * @return
     */
    public static  Function applyIfNotNullOrDefault(final java.util.function.Function mapperA,
            final java.util.function.Function mapperB, final R defaultValue) {
        N.checkArgNotNull(mapperA);
        N.checkArgNotNull(mapperB);

        return a -> {
            if (a == null) {
                return defaultValue;
            }

            final B b = mapperA.apply(a);

            if (b == null) {
                return defaultValue;
            } else {
                return mapperB.apply(b);
            }
        };
    }

    /**
     * Apply if not null or default.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param mapperA
     * @param mapperB
     * @param mapperC
     * @param defaultValue
     * @return
     */
    public static  Function applyIfNotNullOrDefault(final java.util.function.Function mapperA,
            final java.util.function.Function mapperB, final java.util.function.Function mapperC, final R defaultValue) {
        N.checkArgNotNull(mapperA);
        N.checkArgNotNull(mapperB);
        N.checkArgNotNull(mapperC);

        return a -> {
            if (a == null) {
                return defaultValue;
            }

            final B b = mapperA.apply(a);

            if (b == null) {
                return defaultValue;
            }

            final C c = mapperB.apply(b);

            if (c == null) {
                return defaultValue;
            } else {
                return mapperC.apply(c);
            }
        };
    }

    /**
     * Apply if not null or default.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param mapperA
     * @param mapperB
     * @param mapperC
     * @param mapperD
     * @param defaultValue
     * @return
     */
    public static  Function applyIfNotNullOrDefault(final java.util.function.Function mapperA,
            final java.util.function.Function mapperB, final java.util.function.Function mapperC,
            final java.util.function.Function mapperD, final R defaultValue) {
        N.checkArgNotNull(mapperA);
        N.checkArgNotNull(mapperB);
        N.checkArgNotNull(mapperC);
        N.checkArgNotNull(mapperD);

        return a -> {
            if (a == null) {
                return defaultValue;
            }

            final B b = mapperA.apply(a);

            if (b == null) {
                return defaultValue;
            }

            final C c = mapperB.apply(b);

            if (c == null) {
                return defaultValue;
            }

            final D d = mapperC.apply(c);

            if (d == null) {
                return defaultValue;
            } else {
                return mapperD.apply(d);
            }
        };
    }

    /**
     * Apply if not null or get.
     *
     * @param 
     * @param 
     * @param 
     * @param mapperA
     * @param mapperB
     * @param supplier
     * @return
     */
    public static  Function applyIfNotNullOrGet(final java.util.function.Function mapperA,
            final java.util.function.Function mapperB, final java.util.function.Supplier supplier) {
        N.checkArgNotNull(mapperA);
        N.checkArgNotNull(mapperB);

        return a -> {
            if (a == null) {
                return supplier.get();
            }

            final B b = mapperA.apply(a);

            if (b == null) {
                return supplier.get();
            } else {
                return mapperB.apply(b);
            }
        };
    }

    /**
     * Apply if not null or get.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param mapperA
     * @param mapperB
     * @param mapperC
     * @param supplier
     * @return
     */
    public static  Function applyIfNotNullOrGet(final java.util.function.Function mapperA,
            final java.util.function.Function mapperB, final java.util.function.Function mapperC,
            final java.util.function.Supplier supplier) {
        N.checkArgNotNull(mapperA);
        N.checkArgNotNull(mapperB);
        N.checkArgNotNull(mapperC);

        return a -> {
            if (a == null) {
                return supplier.get();
            }

            final B b = mapperA.apply(a);

            if (b == null) {
                return supplier.get();
            }

            final C c = mapperB.apply(b);

            if (c == null) {
                return supplier.get();
            } else {
                return mapperC.apply(c);
            }
        };
    }

    /**
     * Apply if not null or get.
     *
     * @param 
     * @param 
     * @param 
     * @param 
     * @param 
     * @param mapperA
     * @param mapperB
     * @param mapperC
     * @param mapperD
     * @param supplier
     * @return
     */
    public static  Function applyIfNotNullOrGet(final java.util.function.Function mapperA,
            final java.util.function.Function mapperB, final java.util.function.Function mapperC,
            final java.util.function.Function mapperD, final java.util.function.Supplier supplier) {
        N.checkArgNotNull(mapperA);
        N.checkArgNotNull(mapperB);
        N.checkArgNotNull(mapperC);
        N.checkArgNotNull(mapperD);

        return a -> {
            if (a == null) {
                return supplier.get();
            }

            final B b = mapperA.apply(a);

            if (b == null) {
                return supplier.get();
            }

            final C c = mapperB.apply(b);

            if (c == null) {
                return supplier.get();
            }

            final D d = mapperC.apply(c);

            if (d == null) {
                return supplier.get();
            } else {
                return mapperD.apply(d);
            }
        };
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param func
     * @return
     */
    public static  Function, Map.Entry> mapKey(final java.util.function.Function func) {
        N.checkArgNotNull(func);

        return entry -> new ImmutableEntry<>(func.apply(entry.getKey()), entry.getValue());
    }

    /**
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param func
     * @return
     */
    public static  Function, Map.Entry> mapValue(final java.util.function.Function func) {
        N.checkArgNotNull(func);

        return entry -> new ImmutableEntry<>(entry.getKey(), func.apply(entry.getValue()));
    }

    /**
     * Test key val.
     *
     * @param  the key type
     * @param  the value type
     * @param predicate
     * @return
     */
    public static  Predicate> testKeyVal(final java.util.function.BiPredicate predicate) {
        N.checkArgNotNull(predicate);

        return entry -> predicate.test(entry.getKey(), entry.getValue());
    }

    /**
     * Accept key val.
     *
     * @param  the key type
     * @param  the value type
     * @param consumer
     * @return
     */
    public static  Consumer> acceptKeyVal(final java.util.function.BiConsumer consumer) {
        N.checkArgNotNull(consumer);

        return entry -> consumer.accept(entry.getKey(), entry.getValue());
    }

    /**
     * Apply key val.
     *
     * @param  the key type
     * @param  the value type
     * @param 
     * @param func
     * @return
     */
    public static  Function, R> applyKeyVal(final java.util.function.BiFunction func) {
        N.checkArgNotNull(func);

        return entry -> func.apply(entry.getKey(), entry.getValue());
    }

    private static final Function>, List>> FLAT_TO_MAP_FUNC = Maps::flatToMap;

    /**
     * {a=[1, 2, 3], b=[4, 5, 6], c=[7, 8]} -> [{a=1, b=4, c=7}, {a=2, b=5, c=8}, {a=3, b=6}].
     *
     * @param  the key type
     * @param  the value type
     * @return
     * @see Maps#flatToMap(Map)
     */
    @SuppressWarnings("rawtypes")
    public static  Function>, List>> flatToMap() {
        return (Function) FLAT_TO_MAP_FUNC;
    }

    private static final Function PARSE_BYTE_FUNC = Numbers::toByte;

    /**
     * Parses the byte.
     *
     * @return
     */
    public static Function parseByte() {
        return PARSE_BYTE_FUNC;
    }

    private static final Function PARSE_SHORT_FUNC = Numbers::toShort;

    /**
     * Parses the short.
     *
     * @return
     */
    public static Function parseShort() {
        return PARSE_SHORT_FUNC;
    }

    private static final Function PARSE_INT_FUNC = Numbers::toInt;

    /**
     * Parses the int.
     *
     * @return
     */
    public static Function parseInt() {
        return PARSE_INT_FUNC;
    }

    private static final Function PARSE_LONG_FUNC = Numbers::toLong;

    /**
     * Parses the long.
     *
     * @return
     */
    public static Function parseLong() {
        return PARSE_LONG_FUNC;
    }

    private static final Function PARSE_FLOAT_FUNC = Numbers::toFloat;

    /**
     * Parses the float.
     *
     * @return
     */
    public static Function parseFloat() {
        return PARSE_FLOAT_FUNC;
    }

    private static final Function PARSE_DOUBLE_FUNC = Numbers::toDouble;

    /**
     * Parses the double.
     *
     * @return
     */
    public static Function parseDouble() {
        return PARSE_DOUBLE_FUNC;
    }

    private static final Function CREATE_NUMBER_FUNC = t -> N.isNullOrEmpty(t) ? null
            : Numbers.createNumber(t).orElseThrow(() -> new NumberFormatException("Invalid number: " + t));

    /**
     * Creates the number.
     *
     * @return
     * @see Numbers#createNumber(String)
     */
    public static Function createNumber() {
        return CREATE_NUMBER_FUNC;
    }

    /**
     * Num to int.
     *
     * @param 
     * @return
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static  ToIntFunction numToInt() {
        return (ToIntFunction) ToIntFunction.FROM_NUM;
    }

    /**
     * Num to long.
     *
     * @param 
     * @return
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static  ToLongFunction numToLong() {
        return (ToLongFunction) ToLongFunction.FROM_NUM;
    }

    /**
     * Num to double.
     *
     * @param 
     * @return
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static  ToDoubleFunction numToDouble() {
        return (ToDoubleFunction) ToDoubleFunction.FROM_NUM;
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param limit
     * @param predicate
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Predicate limitThenFilter(final int limit, final java.util.function.Predicate predicate) {
        N.checkArgNotNull(predicate);

        return new Predicate<>() {
            private final AtomicInteger counter = new AtomicInteger(limit);

            @Override
            public boolean test(T t) {
                return counter.getAndDecrement() > 0 && predicate.test(t);
            }
        };
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param 
     * @param limit
     * @param predicate
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  BiPredicate limitThenFilter(final int limit, final java.util.function.BiPredicate predicate) {
        N.checkArgNotNull(predicate);

        return new BiPredicate<>() {
            private final AtomicInteger counter = new AtomicInteger(limit);

            @Override
            public boolean test(T t, U u) {
                return counter.getAndDecrement() > 0 && predicate.test(t, u);
            }
        };
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param predicate
     * @param limit
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Predicate filterThenLimit(final java.util.function.Predicate predicate, final int limit) {
        N.checkArgNotNull(predicate);

        return new Predicate<>() {
            private final AtomicInteger counter = new AtomicInteger(limit);

            @Override
            public boolean test(T t) {
                return predicate.test(t) && counter.getAndDecrement() > 0;
            }
        };
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param 
     * @param predicate
     * @param limit
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  BiPredicate filterThenLimit(final java.util.function.BiPredicate predicate, final int limit) {
        N.checkArgNotNull(predicate);

        return new BiPredicate<>() {
            private final AtomicInteger counter = new AtomicInteger(limit);

            @Override
            public boolean test(T t, U u) {
                return predicate.test(t, u) && counter.getAndDecrement() > 0;
            }
        };
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param timeInMillis
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Predicate timeLimit(final long timeInMillis) {
        N.checkArgNotNegative(timeInMillis, "timeInMillis");

        if (timeInMillis == 0) {
            return Fn.alwaysFalse();
        }

        final MutableBoolean ongoing = MutableBoolean.of(true);

        final TimerTask task = new TimerTask() {
            @Override
            public void run() {
                ongoing.setFalse();
            }
        };

        timer.schedule(task, timeInMillis);

        return t -> ongoing.value();
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param duration
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Predicate timeLimit(final Duration duration) {
        N.checkArgNotNull(duration, "duration");

        return timeLimit(duration.toMillis());
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Function> indexed() {
        return new Function<>() {
            private final MutableLong idx = new MutableLong(0);

            @Override
            public Indexed apply(T t) {
                return Indexed.of(t, idx.getAndIncrement());
            }
        };
    }

    /**
     * Returns a stateful Predicate. Don't save or cache for reuse or use it in parallel stream.
     *
     * @param 
     * @param predicate
     * @return
     */
    @Beta
    @SequentialOnly
    @Stateful
    public static  Predicate indexed(final IndexedPredicate predicate) {
        return Predicates.indexed(predicate);
    }

    /** The Constant RETURN_FIRST. */
    private static final BinaryOperator