Ich habe versucht, Java Optional und Guard-Klausel koexistieren zu lassen

Das Problem ist, dass Java SE 8 Optional nicht mit der Schutzklausel kompatibel ist. Ich fragte mich, ob es irgendwie mit der Schutzklausel koexistieren könnte.

package com.ikemo3;

import java.util.Optional;

public class Main {

    public static void main(String[] args) {
        System.out.println(Main.sqrt("16"));
        System.out.println(Main.sqrt("-16"));
        System.out.println(Main.sqrt("str"));
    }

    public static String sqrt(String str) {
        return Optionals.of(str, String.class)
                .guard((s) -> toInteger(s), () -> "Keine ganze Zahl")
                .guard((i) -> sqrt(i), () -> "Keine positive Zahl")
                .get((d) -> String.valueOf(d));
    }

    /**
     *Wenn der Wert positiv ist, machen Sie ihn zu einer Ganzzahl
     */
    public static Optional<Integer> toInteger(String str) {
        try {
            return Optional.of(Integer.valueOf(str));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    /**
     *Wenn der Wert positiv ist, ziehen Sie die Quadratwurzel
     */
    public static Optional<Double> sqrt(int i) {
        if (i >= 0) {
            return Optional.of(Math.sqrt(i));
        } else {
            return Optional.empty();
        }
    }
}

Das Ausgabeergebnis ist wie folgt.

4.0
Keine positive Zahl
Keine ganze Zahl

Wie man anruft ist so. Ich frage mich, ob es wie eine Schutzklausel aussieht.

    public static String sqrt(String str) {
        return Optionals.of(str, String.class)
                .guard((s) -> toInteger(s), () -> "Keine ganze Zahl")
                .guard((i) -> sqrt(i), () -> "Keine positive Zahl")
                .get((d) -> String.valueOf(d));
    }

Die Implementierung der Klasse ist wie folgt.

package com.ikemo3;

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

public class Optionals<IN, RET> {
    private final IN value;
    private final RET elseValue;
    private final Class<RET> clazz;

    public static <IN, OUT> Optionals<IN, OUT> of(IN value, Class<OUT> clazz) {
        return new Optionals(value, clazz);
    }

    private Optionals(IN value, Class<RET> clazz) {
        this.value = value;
        this.clazz = clazz;
        this.elseValue = null;
    }

    private Optionals(RET elseValue) {
        this.value = null;
        this.clazz = null;
        this.elseValue = elseValue;
    }

    public <OUT> Optionals<OUT, RET> guard(Function<IN, Optional<OUT>> func, Supplier<RET> elseValue) {
        if (this.elseValue != null) {
            return new Optionals(this.elseValue);
        }

        Optional<OUT> result = func.apply(this.value);
        if (result.isPresent()) {
            return Optionals.of(result.get(), this.clazz);
        } else {
            return new Optionals(elseValue.get());
        }
    }

    public RET get(Function<IN, RET> func) {
        if (this.elseValue != null) {
            return this.elseValue;
        } else {
            return func.apply(this.value);
        }
    }
}