ClassToRefactor_Copy.java

package me;

import java.util.Collection;
import java.util.function.Function;

public interface ClassToRefactor_Copy {

    default void sendMessages(Collection<ParseResult<InputMessage>> parsedMessages) {
        parsedMessages.stream()
                .map(parsedMessage ->
                        parsedMessage
                                .map(inputMessage -> {
                                    if (inputMessage.isFastLane()) {
                                        return Command.send(convert(inputMessage), getBusSender());
                                    } else {
                                        return Command.log("not a fast lane message " + inputMessage);
                                    }
                                })
                                .getOrElse(Command.log("failure here: " + parsedMessage.getException())))
                .forEach(Command::run);

//        for (ParseResult<InputMessage> parsedMessage : parsedMessages) {
//            if (parsedMessage.isSuccess()) {
//                InputMessage inputMessage = parsedMessage.getOrThrow();
//                if (inputMessage.isFastLane()) {
//                    BusMessage busMessage = convert(inputMessage);
//                    getBusSender().sendBusMessage(busMessage);
//                } else {
//                    log("not a fast lane message " + inputMessage);
//                }
//            } else {
//                log("failure here: " + parsedMessage.getException());
//            }
//        }

    }

    BusSender getBusSender();

    BusMessage convert(InputMessage inputMessage);

    void log(String log);

    interface Command {
        static Command send(BusMessage busMessage, BusSender sender) {
            return () -> sender.sendBusMessage(busMessage);
        }

        static Command log(String message) {
            return () -> log(message);
        }

        void run();
    }


    interface BusSender {
        void sendBusMessage(BusMessage busMessage);
    }

    interface BusMessage {
    }

    interface InputMessage {
        boolean isFastLane();
    }

    interface ParseResult<T> {
        static <T> ParseResult<T> success(T value) {
            return new ParseResult<T>() {
                @Override
                public boolean isSuccess() {
                    return true;
                }

                @Override
                public <U> ParseResult<U> map(Function<T, U> f) {
                    return success(f.apply(value));
                }

                @Override
                public T getOrElse(T defaultvalue) {
                    return value;
                }

                @Override
                public T getOrThrow() {
                    return value;
                }

                @Override
                public Exception getException() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        static <T> ParseResult<T> failure(RuntimeException exception) {
            return new ParseResult<T>() {
                @Override
                public boolean isSuccess() {
                    return false;
                }

                @Override
                public <U> ParseResult<U> map(Function<T, U> f) {
                    return (ParseResult<U>) this;
                }

                @Override
                public T getOrElse(T defaultvalue) {
                    return defaultvalue;
                }

                @Override
                public T getOrThrow() {
                    throw exception;
                }

                @Override
                public Exception getException() {
                    return exception;
                }
            };
        }

        boolean isSuccess();

        <U> ParseResult<U> map(Function<T, U> f);

        T getOrElse(T defaultvalue);

        T getOrThrow();

        Exception getException();
    }

}