package smalljava;

/*

Adapts interfaces in java.util.function and Runnable to interfaces that can throw exceptions.

NOTE: DO NOT import static smalljava.Sneaky.* or you'll import all those interfaces

Example:

var textFiles = Files.walk(Path.of("."))
    .filter(p -> p.toString().endsWith(".txt"))
    .map(Sneaky.Function.of(Files::readString))
    .toList();

Sometimes, you can use Sneaky.of rather than Sneaky.<Interface>.of:
    
Files.walk(Path.of(".")).forEach(Sneaky.of(p -> { dump(p); })); // Ok, shorter
Files.walk(Path.of(".")).forEach(Sneaky.of(p -> dump(p))); // Error, ambiguous
Files.walk(Path.of(".")).forEach(Sneaky.of(ClassName::dump)); // Ok if class has name and dump is static
Files.walk(Path.of(".")).forEach(Sneaky.of(this::dump)); // Ok if dump is not static
Files.walk(Path.of(".")).forEach(Sneaky.of((Sneaky.Consumer<Path, Exception>) p -> dump(p))); // Ugh 
Files.walk(Path.of(".")).forEach(Sneaky.Consumer.of(p -> dump(p))); // Ok

The following is useful for "global" variables in compact source files:

Sometype variable = Sneaky.call(() -> constructor or factory with checked exception);

Background:

https://github.com/rainerhahnekamp/sneakythrow
https://blog.jooq.org/use-joo%CE%BBs-sneaky-throw-to-avoid-checked-exceptions/
https://www.javathinking.com/blog/generalized-target-type-inference-in-java/

*/



public class Sneaky {
    @SuppressWarnings("unchecked")
    public static <T extends Throwable, R> R throwAs(Throwable t) throws T {
        if (t != null) throw (T) t;
        else return null;
    }

    public interface Runnable<X extends Exception> {
        void run() throws X;
        static java.lang.Runnable of(Runnable f) {
            return () -> {
                try {
                    f.run();
                }
                catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }    
    }

    public interface BiConsumer<T, U, X extends Exception> {
        void accept(T t, U u) throws X;

        static <T, U, X extends Exception> java.util.function.BiConsumer<T, U> of(BiConsumer<T, U, X> f) {
            return (t, u) -> {
                try {
                    f.accept(t, u);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface BiFunction<T, U, R, X extends Exception> {
        R apply(T t, U u) throws X;

        static <T, U, R, X extends Exception> java.util.function.BiFunction<T, U, R> of(BiFunction<T, U, R, X> f) {
            return (t, u) -> {
                try {
                    return f.apply(t, u);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, R>throwAs(e);
                }
            };
        }
    }

    public interface BinaryOperator<T, X extends Exception> {
        T apply(T t, T u) throws X;

        static <T, X extends Exception> java.util.function.BinaryOperator<T> of(BinaryOperator<T, X> f) {
            return (t, u) -> {
                try {
                    return f.apply(t, u);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, T>throwAs(e);
                }
            };
        }
    }

    public interface BiPredicate<T, U, X extends Exception> {
        boolean test(T t, U u) throws X;

        static <T, U, X extends Exception> java.util.function.BiPredicate<T, U> of(BiPredicate<T, U, X> f) {
            return (t, u) -> {
                try {
                    return f.test(t, u);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Boolean>throwAs(e);
                }
            };
        }
    }

    public interface BooleanSupplier<X extends Exception> {
        boolean getAsBoolean() throws X;

        static <X extends Exception> java.util.function.BooleanSupplier of(BooleanSupplier<X> f) {
            return () -> {
                try {
                    return f.getAsBoolean();
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Boolean>throwAs(e);
                }
            };
        }
    }

    public interface Consumer<T, X extends Exception> {
        void accept(T t) throws X;
        
        static <T, X extends Exception> java.util.function.Consumer<T> of(Consumer<T, X> f) {
            return x -> {
                try {
                    f.accept(x);
                }
                catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }    
    }        

    public interface DoubleBinaryOperator<X extends Exception> {
        double applyAsDouble(double left, double right) throws X;

        static <X extends Exception> java.util.function.DoubleBinaryOperator of(DoubleBinaryOperator<X> f) {
            return (x, y) -> {
                try {
                    return f.applyAsDouble(x, y);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface DoubleConsumer<X extends Exception> {
        void accept(double value) throws X;

        static <X extends Exception> java.util.function.DoubleConsumer of(DoubleConsumer<X> f) {
            return x -> {
                try {
                    f.accept(x);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface DoubleFunction<R, X extends Exception> {
        R apply(double value) throws X;

        static <R, X extends Exception> java.util.function.DoubleFunction<R> of(DoubleFunction<R, X> f) {
            return x -> {
                try {
                    return f.apply(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, R>throwAs(e);
                }
            };
        }
    }

    public interface DoublePredicate<X extends Exception> {
        boolean test(double value) throws X;

        static <X extends Exception> java.util.function.DoublePredicate of(DoublePredicate<X> f) {
            return x -> {
                try {
                    return f.test(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Boolean>throwAs(e);
                }
            };
        }
    }

    public interface DoubleSupplier<X extends Exception> {
        double getAsDouble() throws X;

        static <X extends Exception> java.util.function.DoubleSupplier of(DoubleSupplier<X> f) {
            return () -> {
                try {
                    return f.getAsDouble();
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface DoubleToIntFunction<X extends Exception> {
        int applyAsInt(double value) throws X;

        static <X extends Exception> java.util.function.DoubleToIntFunction of(DoubleToIntFunction<X> f) {
            return x -> {
                try {
                    return f.applyAsInt(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface DoubleToLongFunction<X extends Exception> {
        long applyAsLong(double value) throws X;

        static <X extends Exception> java.util.function.DoubleToLongFunction of(DoubleToLongFunction<X> f) {
            return x -> {
                try {
                    return f.applyAsLong(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface DoubleUnaryOperator<X extends Exception> {
        double applyAsDouble(double value) throws X;

        static <X extends Exception> java.util.function.DoubleUnaryOperator of(DoubleUnaryOperator<X> f) {
            return x -> {
                try {
                    return f.applyAsDouble(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface Function<T, R, X extends Exception> {
        R apply(T input) throws X;
        
        static <T, R, X extends Exception> java.util.function.Function<T, R> of(Function<T, R, X> f) {
            return x -> {
                try {
                    return f.apply(x);
                }
                catch (Exception e) {
                    return Sneaky.<RuntimeException, R>throwAs(e);
                }
            };
        }
    }

    public interface IntBinaryOperator<X extends Exception> {
        int applyAsInt(int left, int right) throws X;

        static <X extends Exception> java.util.function.IntBinaryOperator of(IntBinaryOperator<X> f) {
            return (x, y) -> {
                try {
                    return f.applyAsInt(x, y);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface IntConsumer<X extends Exception> {
        void accept(int value) throws X;

        static <X extends Exception> java.util.function.IntConsumer of(IntConsumer<X> f) {
            return x -> {
                try {
                    f.accept(x);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface IntFunction<R, X extends Exception> {
        R apply(int value) throws X;

        static <R, X extends Exception> java.util.function.IntFunction<R> of(IntFunction<R, X> f) {
            return x -> {
                try {
                    return f.apply(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, R>throwAs(e);
                }
            };
        }
    }

    public interface IntPredicate<X extends Exception> {
        boolean test(int value) throws X;

        static <X extends Exception> java.util.function.IntPredicate of(IntPredicate<X> f) {
            return x -> {
                try {
                    return f.test(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Boolean>throwAs(e);
                }
            };
        }
    }

    public interface IntSupplier<X extends Exception> {
        int getAsInt() throws X;

        static <X extends Exception> java.util.function.IntSupplier of(IntSupplier<X> f) {
            return () -> {
                try {
                    return f.getAsInt();
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface IntToDoubleFunction<X extends Exception> {
        double applyAsDouble(int value) throws X;

        static <X extends Exception> java.util.function.IntToDoubleFunction of(IntToDoubleFunction<X> f) {
            return x -> {
                try {
                    return f.applyAsDouble(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface IntToLongFunction<X extends Exception> {
        long applyAsLong(int value) throws X;

        static <X extends Exception> java.util.function.IntToLongFunction of(IntToLongFunction<X> f) {
            return x -> {
                try {
                    return f.applyAsLong(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface IntUnaryOperator<X extends Exception> {
        int applyAsInt(int value) throws X;

        static <X extends Exception> java.util.function.IntUnaryOperator of(IntUnaryOperator<X> f) {
            return x -> {
                try {
                    return f.applyAsInt(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface LongBinaryOperator<X extends Exception> {
        long applyAsLong(long left, long right) throws X;

        static <X extends Exception> java.util.function.LongBinaryOperator of(LongBinaryOperator<X> f) {
            return (x, y) -> {
                try {
                    return f.applyAsLong(x, y);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface LongConsumer<X extends Exception> {
        void accept(long value) throws X;

        static <X extends Exception> java.util.function.LongConsumer of(LongConsumer<X> f) {
            return x -> {
                try {
                    f.accept(x);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface LongFunction<R, X extends Exception> {
        R apply(long value) throws X;

        static <R, X extends Exception> java.util.function.LongFunction<R> of(LongFunction<R, X> f) {
            return x -> {
                try {
                    return f.apply(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, R>throwAs(e);
                }
            };
        }
    }

    public interface LongPredicate<X extends Exception> {
        boolean test(long value) throws X;

        static <X extends Exception> java.util.function.LongPredicate of(LongPredicate<X> f) {
            return x -> {
                try {
                    return f.test(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Boolean>throwAs(e);
                }
            };
        }
    }

    public interface LongSupplier<X extends Exception> {
        long getAsLong() throws X;

        static <X extends Exception> java.util.function.LongSupplier of(LongSupplier<X> f) {
            return () -> {
                try {
                    return f.getAsLong();
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface LongToDoubleFunction<X extends Exception> {
        double applyAsDouble(long value) throws X;

        static <X extends Exception> java.util.function.LongToDoubleFunction of(LongToDoubleFunction<X> f) {
            return x -> {
                try {
                    return f.applyAsDouble(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface LongToIntFunction<X extends Exception> {
        int applyAsInt(long value) throws X;

        static <X extends Exception> java.util.function.LongToIntFunction of(LongToIntFunction<X> f) {
            return x -> {
                try {
                    return f.applyAsInt(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface LongUnaryOperator<X extends Exception> {
        long applyAsLong(long value) throws X;

        static <X extends Exception> java.util.function.LongUnaryOperator of(LongUnaryOperator<X> f) {
            return x -> {
                try {
                    return f.applyAsLong(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface ObjDoubleConsumer<T, X extends Exception> {
        void accept(T t, double value) throws X;

        static <T, X extends Exception> java.util.function.ObjDoubleConsumer<T> of(ObjDoubleConsumer<T, X> f) {
            return (t, x) -> {
                try {
                    f.accept(t, x);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface ObjIntConsumer<T, X extends Exception> {
        void accept(T t, int value) throws X;

        static <T, X extends Exception> java.util.function.ObjIntConsumer<T> of(ObjIntConsumer<T, X> f) {
            return (t, x) -> {
                try {
                    f.accept(t, x);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface ObjLongConsumer<T, X extends Exception> {
        void accept(T t, long value) throws X;

        static <T, X extends Exception> java.util.function.ObjLongConsumer<T> of(ObjLongConsumer<T, X> f) {
            return (t, x) -> {
                try {
                    f.accept(t, x);
                } catch (Exception e) {
                    Sneaky.<RuntimeException, Void>throwAs(e);
                }
            };
        }
    }

    public interface Predicate<T, X extends Exception> {
        boolean test(T input) throws X;
        
        static <T, X extends Exception> java.util.function.Predicate<T> of(Predicate<T, X> f) {
            return x -> {
                try {
                    return f.test(x);
                }
                catch (Exception e) {
                    return Sneaky.<RuntimeException, Boolean>throwAs(e);
                }
            };
        }
    }
    
    public interface Supplier<T, X extends Exception> {
        T get() throws X;
        static <T, X extends Exception> java.util.function.Supplier<T> of(Supplier<T, X> f) {
            return () -> {
                try {
                    return f.get();
                }
                catch (Exception e) {
                    return Sneaky.<RuntimeException, T>throwAs(e);
                }
            };
        }    
    }        
    
    public interface ToDoubleBiFunction<T, U, X extends Exception> {
        double applyAsDouble(T t, U u) throws X;

        static <T, U, X extends Exception> java.util.function.ToDoubleBiFunction<T, U> of(ToDoubleBiFunction<T, U, X> f) {
            return (t, u) -> {
                try {
                    return f.applyAsDouble(t, u);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface ToDoubleFunction<T, X extends Exception> {
        double applyAsDouble(T value) throws X;

        static <T, X extends Exception> java.util.function.ToDoubleFunction<T> of(ToDoubleFunction<T, X> f) {
            return x -> {
                try {
                    return f.applyAsDouble(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Double>throwAs(e);
                }
            };
        }
    }

    public interface ToIntBiFunction<T, U, X extends Exception> {
        int applyAsInt(T t, U u) throws X;

        static <T, U, X extends Exception> java.util.function.ToIntBiFunction<T, U> of(ToIntBiFunction<T, U, X> f) {
            return (t, u) -> {
                try {
                    return f.applyAsInt(t, u);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface ToIntFunction<T, X extends Exception> {
        int applyAsInt(T value) throws X;

        static <T, X extends Exception> java.util.function.ToIntFunction<T> of(ToIntFunction<T, X> f) {
            return x -> {
                try {
                    return f.applyAsInt(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Integer>throwAs(e);
                }
            };
        }
    }

    public interface ToLongBiFunction<T, U, X extends Exception> {
        long applyAsLong(T t, U u) throws X;

        static <T, U, X extends Exception> java.util.function.ToLongBiFunction<T, U> of(ToLongBiFunction<T, U, X> f) {
            return (t, u) -> {
                try {
                    return f.applyAsLong(t, u);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface ToLongFunction<T, X extends Exception> {
        long applyAsLong(T value) throws X;

        static <T, X extends Exception> java.util.function.ToLongFunction<T> of(ToLongFunction<T, X> f) {
            return x -> {
                try {
                    return f.applyAsLong(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, Long>throwAs(e);
                }
            };
        }
    }

    public interface UnaryOperator<T, X extends Exception> {
        T apply(T t) throws X;
        static <T, X extends Exception> java.util.function.UnaryOperator<T> of(UnaryOperator<T, X> f) {
            return x -> {
                try {
                    return f.apply(x);
                } catch (Exception e) {
                    return Sneaky.<RuntimeException, T>throwAs(e);
                }
            };
        }
    }

    public static java.lang.Runnable of(Runnable f) {
        return Runnable.of(f);
    }
    
    public static <T, U, X extends Exception> java.util.function.BiConsumer<T, U>
        of(BiConsumer<T, U, X> f) {
        return BiConsumer.of(f);
    }

    public static <T, U, R, X extends Exception> java.util.function.BiFunction<T, U, R>
        of(BiFunction<T, U, R, X> f) {
        return BiFunction.of(f);
    }

    public static <T, U, X extends Exception> java.util.function.BiPredicate<T, U>
        of(BiPredicate<T, U, X> f) {
        return BiPredicate.of(f);
    }

    public static <T, X extends Exception> java.util.function.BinaryOperator<T>
        of(BinaryOperator<T, X> f) {
        return BinaryOperator.of(f);
    }

    public static <X extends Exception> java.util.function.BooleanSupplier
        of(BooleanSupplier<X> f) {
        return BooleanSupplier.of(f);
    }

    public static <T, X extends Exception> java.util.function.Consumer<T>
        of(Consumer<T, X> f) {
        return Consumer.of(f);
    }

    public static <X extends Exception> java.util.function.DoubleBinaryOperator
        of(DoubleBinaryOperator<X> f) {
        return DoubleBinaryOperator.of(f);
    }

    public static <X extends Exception> java.util.function.DoubleConsumer
        of(DoubleConsumer<X> f) {
        return DoubleConsumer.of(f);
    }

    public static <R, X extends Exception> java.util.function.DoubleFunction<R>
        of(DoubleFunction<R, X> f) {
        return DoubleFunction.of(f);
    }

    public static <X extends Exception> java.util.function.DoublePredicate
        of(DoublePredicate<X> f) {
        return DoublePredicate.of(f);
    }

    public static <X extends Exception> java.util.function.DoubleSupplier
        of(DoubleSupplier<X> f) {
        return DoubleSupplier.of(f);
    }

    public static <X extends Exception> java.util.function.DoubleToIntFunction
        of(DoubleToIntFunction<X> f) {
        return DoubleToIntFunction.of(f);
    }

    public static <X extends Exception> java.util.function.DoubleToLongFunction
        of(DoubleToLongFunction<X> f) {
        return DoubleToLongFunction.of(f);
    }

    public static <X extends Exception> java.util.function.DoubleUnaryOperator
        of(DoubleUnaryOperator<X> f) {
        return DoubleUnaryOperator.of(f);
    }

    public static <T, R, X extends Exception> java.util.function.Function<T, R>
        of(Function<T, R, X> f) {
        return Function.of(f);
    }

    public static <X extends Exception> java.util.function.IntBinaryOperator
        of(IntBinaryOperator<X> f) {
        return IntBinaryOperator.of(f);
    }

    public static <X extends Exception> java.util.function.IntConsumer
        of(IntConsumer<X> f) {
        return IntConsumer.of(f);
    }

    public static <R, X extends Exception> java.util.function.IntFunction<R>
        of(IntFunction<R, X> f) {
        return IntFunction.of(f);
    }

    public static <X extends Exception> java.util.function.IntPredicate
        of(IntPredicate<X> f) {
        return IntPredicate.of(f);
    }

    public static <X extends Exception> java.util.function.IntSupplier
        of(IntSupplier<X> f) {
        return IntSupplier.of(f);
    }

    public static <X extends Exception> java.util.function.IntToDoubleFunction
        of(IntToDoubleFunction<X> f) {
        return IntToDoubleFunction.of(f);
    }

    public static <X extends Exception> java.util.function.IntToLongFunction
        of(IntToLongFunction<X> f) {
        return IntToLongFunction.of(f);
    }

    public static <X extends Exception> java.util.function.IntUnaryOperator
        of(IntUnaryOperator<X> f) {
        return IntUnaryOperator.of(f);
    }

    public static <X extends Exception> java.util.function.LongBinaryOperator
        of(LongBinaryOperator<X> f) {
        return LongBinaryOperator.of(f);
    }

    public static <X extends Exception> java.util.function.LongConsumer
        of(LongConsumer<X> f) {
        return LongConsumer.of(f);
    }

    public static <R, X extends Exception> java.util.function.LongFunction<R>
        of(LongFunction<R, X> f) {
        return LongFunction.of(f);
    }

    public static <X extends Exception> java.util.function.LongPredicate
        of(LongPredicate<X> f) {
        return LongPredicate.of(f);
    }

    public static <X extends Exception> java.util.function.LongSupplier
        of(LongSupplier<X> f) {
        return LongSupplier.of(f);
    }

    public static <X extends Exception> java.util.function.LongToDoubleFunction
        of(LongToDoubleFunction<X> f) {
        return LongToDoubleFunction.of(f);
    }

    public static <X extends Exception> java.util.function.LongToIntFunction
        of(LongToIntFunction<X> f) {
        return LongToIntFunction.of(f);
    }

    public static <X extends Exception> java.util.function.LongUnaryOperator
        of(LongUnaryOperator<X> f) {
        return LongUnaryOperator.of(f);
    }

    public static <T, X extends Exception> java.util.function.ObjDoubleConsumer<T>
        of(ObjDoubleConsumer<T, X> f) {
        return ObjDoubleConsumer.of(f);
    }

    public static <T, X extends Exception> java.util.function.ObjIntConsumer<T>
        of(ObjIntConsumer<T, X> f) {
        return ObjIntConsumer.of(f);
    }

    public static <T, X extends Exception> java.util.function.ObjLongConsumer<T>
        of(ObjLongConsumer<T, X> f) {
        return ObjLongConsumer.of(f);
    }

    public static <T, X extends Exception> java.util.function.Predicate<T>
        of(Predicate<T, X> f) {
        return Predicate.of(f);
    }

    public static <T, X extends Exception> java.util.function.Supplier<T>
        of(Supplier<T, X> f) {
        return Supplier.of(f);
    }

    public static <T, U, X extends Exception> java.util.function.ToDoubleBiFunction<T, U>
        of(ToDoubleBiFunction<T, U, X> f) {
        return ToDoubleBiFunction.of(f);
    }

    public static <T, X extends Exception> java.util.function.ToDoubleFunction<T>
        of(ToDoubleFunction<T, X> f) {
        return ToDoubleFunction.of(f);
    }

    public static <T, U, X extends Exception> java.util.function.ToIntBiFunction<T, U>
        of(ToIntBiFunction<T, U, X> f) {
        return ToIntBiFunction.of(f);
    }

    public static <T, X extends Exception> java.util.function.ToIntFunction<T>
        of(ToIntFunction<T, X> f) {
        return ToIntFunction.of(f);
    }

    public static <T, U, X extends Exception> java.util.function.ToLongBiFunction<T, U>
        of(ToLongBiFunction<T, U, X> f) {
        return ToLongBiFunction.of(f);
    }

    public static <T, X extends Exception> java.util.function.ToLongFunction<T>
        of(ToLongFunction<T, X> f) {
        return ToLongFunction.of(f);
    }

    public static <T, X extends Exception> java.util.function.UnaryOperator<T>
        of(UnaryOperator<T, X> f) {
        return UnaryOperator.of(f);
    }
   
    public static <T> T call(java.util.concurrent.Callable<T> f) {
        try {
            return f.call();
        }
        catch (Exception e) {
            return Sneaky.<RuntimeException, T>throwAs(e);
        }
    }
}