How to use Either in java?

[gusega]

Hi,

I have a method

public Either<String, MyType> create() {
  // if something
  return new Either.Right<>(new MyType())
  // otherwise
  return new Either.Left<>("error message");
}

I get a warning when returning Either.Right and Either.Left:

Unchecked assignment: 'arrow.core.Either.Right<MyType>' to 'arrow.core.Either<java.lang.String, MyType>

Unchecked assignment: 'arrow.core.Either.Left<java.lang.String>' to 'arrow.core.Either<java.lang.String, MyType>

How do I create them?

I think the problem is that Left and Right do not declare a type parameter for the "missing" part. Instead they have Nothing.

[nomisRev]

Hey @gusega,

Thank you for raising this issue.. I was not aware that Either.Right and EitherKt.right both caused this issue because covariance is not correctly respected from Java.. Beside of course creating a custom EitherUtils or similar with a smart-constructor suppressing the warning.

I think it's going to be rather hard to fix, I think adding <E> parameter to EitherKt.right will break too much code. I don't think there would be any other option here cc\ @serras.

Cool thing is you can pretty nicely use the RaiseKt DSL from Java!

import arrow.core.Either;

import static arrow.core.raise.RaiseKt.either;

public class EitherExample {
    public Either<String, Integer> multiline(Either<String, Integer> other ) {
        return either(raise -> {
            int x = 2;
            var z = raise.bind(other);
            return x + z;
        });
    }

    public Either<String, Integer> singleline(Either<String, Integer> other ) {
        return either(raise -> 2 + raise.bind(other));
    }
}

[serras]

Indeed, declaring the additional parameters in Right and Left would break a lot of code, because type inference would be much much worse.

I agree that some sort of Either.Right.of function declared with the additional parameter could work (and we can mark it with @Deprecated(HIDDEN) to hide it in the Kotlin side). However, I'm a bit hesitant of the actual benefit, since the Java compiler won't be able to infer the not present type argument, so you'll have to be explicit about it...

Either.Right.of<String, Integer>(3)

Is that better than (Either<String, Integer>) Either.Right(3)?

[gusega]

I think when I explicitly casted new Either.Right(3) to Either<String, Integer> java gave me a warning. So if this .of() function eliminates warning, then I think it's better.

[serras]

But the caveat would be that you need to specify the type arguments explicitly...