Either i problem z niezgodnością typów błędów

static Either<AccountError,Account> create(
String userNameCandidate,
UserNameUniquenessValidator userNameUniquenessValidator,
String passwordCandidate,
PasswordEncoder passwordEncoder) {

       return UserName
                .create(userNameCandidate,userNameUniquenessValidator)
                .flatMap(correctUserName -> Password
                        .create(passwordCandidate,passwordEncoder)
                        .map(correctPassword -> new Account(correctUserName,correctPassword)));
    }

@Embeddable
final class UserName implements Serializable {

    public static final Integer MIN_USER_NAME_LENGTH = 3;

    public static final Integer MAX_USER_NAME_LENGTH = 15;

    @Column
    private final String userName;

    UserName(String userNam) {
        this.userName = userNam;
    }

    //For JPA only.Don't use!
    public UserName() {

        this.userName = "default";
    }

    static Either<WrongUserNameFormatError,UserName> create(
            String userNameCandidate,
            UserNameUniquenessValidator userNameUniquenessValidator) {

        if (userNameCandidate.isEmpty()) {

            return Either.left(new WrongUserNameFormatError("Empty user name."));
        }

        var isUserNameCandidateLengthWrong =
                userNameCandidate.length() < MIN_USER_NAME_LENGTH &&
                userNameCandidate.length() > MAX_USER_NAME_LENGTH;

        if (isUserNameCandidateLengthWrong) {

            return Either.left(new WrongUserNameFormatError(
                        "Wrong user name length: " + userNameCandidate.length() +
                                ".Min: " + MIN_USER_NAME_LENGTH +
                                ".Max: " + MAX_USER_NAME_LENGTH));
        }

        if (!userNameUniquenessValidator.isUnique(userNameCandidate)) {

            return Either.left(new WrongUserNameFormatError("Not unique user name: " + userNameCandidate));
        }

        return Either.right(new UserName(userNameCandidate));
    }

    public String getUserName() {
        return userName;
    }
}

@Embeddable
final class Password implements Serializable {

    public static final Integer MIN_PASSWORD_LENGTH = 5;

    @Column
    private final String password;

    private Password(String password) {
        this.password = password;
    }

    //For JPA only.Don't use!
    public Password() {

        this.password = "default";
    }

    static Either<WrongPasswordFormatError,Password> create(String passwordCandidate, PasswordEncoder passwordEncoder) {

        if (passwordCandidate.length() >= MIN_PASSWORD_LENGTH) {

            var encodedPassword= passwordEncoder.encode(passwordCandidate);

            return Either.right(new Password(encodedPassword));
        }
        else {

            return Either.left(new WrongPasswordFormatError(
                        "Wrong password length: " + passwordCandidate.length() +
                                ". Min: " + MIN_PASSWORD_LENGTH));
        }
    }

    public String getPassword() {
        return password;
    }
}

import scala.util.Either
val e1: Either[String, Int] = Left("Hello World")
val e2: Either[Any, Int] = e1

print(e2)

List<String> x = new ArrayList<String>();
List<Object> y = x; // hmmm
y.add(new Integer(1));
String z = x.get(0); // panic