javaslang.Function0 Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of authorize-net-plugin Show documentation
A Java implementation of a KillBill Payment Plugin that uses Authorize.Net as a payment gateway
There is a newer version: 2.8.196
/*     / \____  _    _  ____   ______  / \ ____  __    _______
 *    /  /    \/ \  / \/    \ /  /\__\/  //    \/  \  //  /\__\   JΛVΛSLΛNG
 *  _/  /  /\  \  \/  /  /\  \\__\\  \  //  /\  \ /\\/ \ /__\ \   Copyright 2014-2016 Javaslang, http://javaslang.io
 * /___/\_/  \_/\____/\_/  \_/\__\/__/\__\_/  \_//  \__/\_____/   Licensed under the Apache License, Version 2.0
 */
package javaslang;

/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*\
   G E N E R A T O R   C R A F T E D
\*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import javaslang.control.Option;
import javaslang.control.Try;

/**
 * Represents a function with no arguments.
 *
 * @param  return type of the function
 * @author Daniel Dietrich
 * @since 1.1.0
 */
@FunctionalInterface
public interface Function0 extends λ, Supplier {

    /**
     * The serial version uid.
     */
    long serialVersionUID = 1L;

    /**
     * Creates a {@code Function0} based on
     * 
     * method reference
     * lambda expression
     * 
     *
     * Examples (w.l.o.g. referring to Function1):
     * // using a lambda expression
     * Function1<Integer, Integer> add1 = Function1.of(i -> i + 1);
     *
     * // using a method reference (, e.g. Integer method(Integer i) { return i + 1; })
     * Function1<Integer, Integer> add2 = Function1.of(this::method);
     *
     * // using a lambda reference
     * Function1<Integer, Integer> add3 = Function1.of(add1::apply);
     * 
     * 
     * Caution: Reflection loses type information of lambda references.
     * 
// type of a lambda expression
     * Type<?, ?> type1 = add1.getType(); // (Integer) -> Integer
     *
     * // type of a method reference
     * Type<?, ?> type2 = add2.getType(); // (Integer) -> Integer
     *
     * // type of a lambda reference
     * Type<?, ?> type3 = add3.getType(); // (Object) -> Object
     * 
     *
     * @param methodReference (typically) a method reference, e.g. {@code Type::method}
     * @param  return type
     * @return a {@code Function0}
     */
    static  Function0 of(Function0 methodReference) {
        return methodReference;
    }

    /**
     * Lifts the given {@code partialFunction} into a total function that returns an {@code Option} result.
     *
     * @param partialFunction a function that is not defined for all values of the domain (e.g. by throwing)
     * @param  return type
     * @return a function that applies arguments to the given {@code partialFunction} and returns {@code Some(result)}
     *         if the function is defined for the given arguments, and {@code None} otherwise.
     */
    static  Function0> lift(Function0 partialFunction) {
        return () -> Try.of(() -> partialFunction.apply()).getOption();
    }

    /**
     * Applies this function to no arguments and returns the result.
     *
     * @return the result of function application
     * 
     */
    R apply();

    /**
     * Implementation of {@linkplain java.util.function.Supplier#get()}, just calls {@linkplain #apply()}.
     *
     * @return the result of {@code apply()}
     */
    @Override
    default R get() {
        return apply();
    }

    @Override
    default int arity() {
        return 0;
    }

    @Override
    default Function0 curried() {
        return this;
    }

    @Override
    default Function1 tupled() {
        return t -> apply();
    }

    @Override
    default Function0 reversed() {
        return this;
    }

    @Override
    default Function0 memoized() {
        if (isMemoized()) {
            return this;
        } else {
            return (Function0 & Memoized) Lazy.of(this::apply)::get;
        }
    }

    /**
     * Returns a composed function that first applies this Function0 to the given argument and then applies
     * {@linkplain Function} {@code after} to the result.
     *
     * @param  return type of after
     * @param after the function applied after this
     * @return a function composed of this and after
     * @throws NullPointerException if after is null
     */
    default  Function0 andThen(Function after) {
        Objects.requireNonNull(after, "after is null");
        return () -> after.apply(apply());
    }

}