Hjälp med en uppgift i Java

public static String uppercase(String s) {
    return s.toUpperCase();
}

...
println(…)
var name = nextLine
println(…)
...
var rentPerSqm = rent / sqm
var formatter = new DecimalFormat(...)
var rentStr = formatter.format(...)
...

class Unit {
    public final static Unit Unit = new Unit();
    private Unit() {}
}

interface Hkt<F, A> {}
interface Hkt2<F, A, B> extends Hkt<Hkt<F, A>, B> {}

interface Monad<F> {
    <A> Hkt<F, A> pure(A a);
    <A, B> Hkt<F, B> flatMap(Hkt<F, A> fa, Function<A, Hkt<F, B>> f);
    default <A, B> Hkt<F, B> flatMap_(Hkt<F, A> fa, Hkt<F, B> fb) { return flatMap(fa, dummy -> fb); }
    default <A, B> Hkt<F, B> map(Hkt<F, A> fa, Function<A, B> f) { return flatMap(fa, f.andThen(this::pure)); }
}

abstract class IO<A> implements Hkt<IO.m, A> {
    static final class m {}

    static <A> IO<A> narrowK(Hkt<IO.m, A> Fa) { return (IO<A>) Fa; }

    public static final IOMonad monad = new IOMonad() {};
    public static final IOConsole console = new IOConsole() {};

    abstract A unsafeRunSync();
}

interface IOMonad extends Monad<IO.m> {
    @Override
    default <A> IO<A> pure(A a) {
        return new IO<>() {
            @Override
            A unsafeRunSync() {
                return a;
            }
        };
    }

    @Override
    default <A, B> IO<B> flatMap(Hkt<IO.m, A> fa, Function<A, Hkt<IO.m, B>> f) {
        return new IO<>() {
            @Override
            B unsafeRunSync() {
                return ((IO<B>) f.apply(((IO<A>) fa).unsafeRunSync())).unsafeRunSync();
            }
        };
    }
}

interface Console<F> {
    Hkt<F, Unit> putStrLn(String s);
    Hkt<F, String> getStrLn();
}

interface IOConsole extends Console<IO.m> {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    default IO<Unit> putStrLn(String s) {
        return new IO<>() {
            @Override
            Unit unsafeRunSync() {
                System.out.println(s);
                return Unit;
            }
        };
    }

    default IO<String> getStrLn() {
        return new IO<>() {
            @Override
            String unsafeRunSync() {
                try {
                    return in.readLine();
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
        };
    }
}

class Tuple<A, B> {
    public final A _1;
    public final B _2;
    Tuple(A a, B b) {
        _1 = a;
        _2 = b;
    }
}

class State<S, A> implements Hkt2<State.m, S, A> {
    public static final class m {}

    static <S, A> State<S, A> narrowK(Hkt<Hkt<State.m, S>, A> Fa) { return (State<S, A>) Fa; }

    public static final StateMonad monad = new StateMonad() {};
    public static final StateConsole console = new StateConsole() {};

    public final Function<S, Tuple<S, A>> run;

    State(Function<S, Tuple<S, A>> run) { this.run = run; }

    public static <S, A> State<S, A> pure(A a) { return new State<>(s -> new Tuple<>(s, a)); }
    public static <S> State<S, Unit> set(S s) { return new State<>(dummy -> new Tuple<>(s, Unit)); }
    public static <S> State<S, S> get() { return new State<>(s -> new Tuple<>(s, s)); }
    public static <S> State<S, Unit> modify(Function<S, S> f) { return new State<>(s -> new Tuple<>(f.apply(s), Unit)); }

    public <B> State<S, B> flatMap(Function<A, State<S, B>> f) {
        return new State<>(s -> {
           var tmp = run.apply(s);
           return f.apply(tmp._2).run.apply(tmp._1);
        });
    }

    public <B> State<S, B> map(Function<A, B> f) { return flatMap(a -> pure(f.apply(a))); }
}

class TestData {
    public final List<String> in;
    public final List<String> out;
    TestData(List<String> in, List<String> out) {
        this.in = in;
        this.out = out;
        }
}

interface StateConsole extends Console<Hkt<State.m, TestData>> {
    @Override
    default State<TestData, Unit> putStrLn(String s) {
        return State.modify(td -> {
            var tdOut = new ArrayList<>(td.out);
            tdOut.add(s);
            return new TestData(td.in, List.copyOf(tdOut));
        });
    }

    @Override
    default State<TestData, String> getStrLn() {
        return new State<>(td -> {
            var tdIn = new ArrayList<>(td.in);
            var head = tdIn.remove(0);
            var tdOut = new ArrayList<>(td.out);
            tdOut.add("(User input: " + head + ")");
            return new Tuple<>(new TestData(List.copyOf(tdIn), List.copyOf(tdOut)), head);
        });
    }
}

interface StateMonad<S> extends Monad<Hkt<State.m, S>> {
    @Override
    default <A> State<S, A> pure(A a) {
        return State.pure(a);
    }

    @Override
    default <A, B> State<S, B> flatMap(Hkt<Hkt<State.m, S>, A> fa, Function<A, Hkt<Hkt<State.m, S>, B>> f) {
        return ((State<S, A>) fa).flatMap(a -> (State<S, B>) f.apply(a));
    }
}

public class Main {
    private static Optional<Integer> parseInt(String s) {
        try {
            return Optional.of(Integer.parseInt(s));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    private static <A, B> B fold(Optional<A> oa, Supplier<B> empty, Function<A, B> present) {
        if(oa.isPresent()) return present.apply(oa.get());
        else return empty.get();
    }

    private static <F> Hkt<F, Integer> rentInput(Monad<F> M, Console<F> C) {
        return
            M.flatMap_(C.putStrLn("Ange din månadshyra:"),
            M.flatMap(C.getStrLn(), rentStr ->
                fold(parseInt(rentStr),
                    () -> M.flatMap_(C.putStrLn("Du måste ange månadshyran som ett heltal"), rentInput(M, C)),
                    rent -> rent < 0 ? M.flatMap_(C.putStrLn("Hyran kan inte vara negativ"), rentInput(M, C)) : M.pure(rent))));
    }

    private static <F> Hkt<F, Integer> sqmInput(Monad<F> M, Console<F> C)  {
        return
            M.flatMap_(C.putStrLn("Ange lägenhetens storlek i kvadratmeter:"),
            M.flatMap(C.getStrLn(), sqmStr ->
                fold(parseInt(sqmStr),
                    () -> M.flatMap_(C.putStrLn("Du måste ange lägenhetens storlek som ett heltal"), sqmInput(M, C)),
                    sqm -> sqm <= 0 ? M.flatMap_(C.putStrLn("Lägenhetens storlek måste vara över 0 kvm"), sqmInput(M, C)) : M.pure(sqm))));

    }

    private static String rentPerSqm(int rent, int sqm) {
        var formatter = new DecimalFormat("0.##");
        return formatter.format((double) rent / sqm);
    }

    private static <F> Hkt<F, Unit> program(Monad<F> M, Console<F> C) {
        return
            M.flatMap_(C.putStrLn("Ange ditt namn:"),
            M.flatMap(M.map(C.getStrLn(), String::toUpperCase), name ->
            M.flatMap(rentInput(M, C), rent ->
            M.flatMap(sqmInput(M, C), sqm ->
                C.putStrLn(name + " du betalar " + rentPerSqm(rent, sqm) + "kr per kvadratmeter i månaden.")))));
    }

    public static void main(String[] args) {
        IO<Unit> program1 = IO.narrowK(program(IO.monad, IO.console));
        program1.unsafeRunSync();

        State<TestData, Unit> program2 =  State.narrowK(program(State.monad, State.console));
        program2.run.apply(new TestData(List.of("John Doe", "2500kr", "-100", "4500", "0m2", "0", "55"),
                List.of()))._1.out.forEach(System.out::println);
    }
}