Java中的Monad设计模式及其实现过程

interface Functor<T, F extends Functor<?, ?>> {
    <R> F map(Function<T, R> f);
}

interface Applicative<T, F extends Applicative<?, ?>> extends Functor<T, F> {
    <R> Applicative<R, F> ap(Applicative<Function<T, R>, F> f);
}

interface Monad<T, M extends Monad<?, ?>> extends Applicative<T, M> {
    <R> Monad<R, M> flatMap(Function<T, Monad<R, M>> f);
}

import java.util.function.Function;

public interface Monad<T> {
    // 将一个函数应用于当前Monad中的值，并返回新的Monad
    <R> Monad<R> flatMap(Function<? super T, ? extends Monad<? extends R>> mapper);

    // 将一个函数应用于当前Monad中的值，并返回包含新值的Monad
    <R> Monad<R> map(Function<? super T, ? extends R> mapper);

    // 获取Monad中的值
    T get();
}

import java.util.Optional;
import java.util.function.Function;

public class OptionalMonad<T> implements Monad<T> {
    private final Optional<T> optional;

    // 私有构造函数，防止外部直接创建实例
    private OptionalMonad(Optional<T> optional) {
        this.optional = optional;
    }

    // 静态工厂方法，用于创建OptionalMonad实例
    public static <T> OptionalMonad<T> of(Optional<T> optional) {
        return new OptionalMonad<>(optional);
    }

    // 实现flatMap方法，将mapper应用于Optional中的值
    @Override
    public <R> OptionalMonad<R> flatMap(Function<? super T, ? extends Monad<? extends R>> mapper) {
        return new OptionalMonad<>(optional.flatMap(
            t -> {
                @SuppressWarnings("unchecked")
                Optional<R> result = ((OptionalMonad<R>) mapper.apply(t)).optional;
                return result;
            }
        ));
    }

    // 实现map方法，将mapper应用于Optional中的值
    @Override
    public <R> OptionalMonad<R> map(Function<? super T, ? extends R> mapper) {
        return new OptionalMonad<>(optional.map(mapper));
    }

    // 获取Optional中的值
    @Override
    public T get() {
        return optional.orElse(null);
    }
}

public class Main {
    public static void main(String[] args) {
        OptionalMonad<Integer> monad = OptionalMonad.of(Optional.of(10));
        
        // 使用map和flatMap链式调用
        OptionalMonad<String> result = monad
            .map(x -> x + 5)  // 将值加5
            .flatMap(x -> OptionalMonad.of(Optional.of("Result: " + x)));  // 将结果转换为字符串并包裹在OptionalMonad中
        
        System.out.println(result.get());  // 输出 "Result: 15"
    }
}