For comprehension for Either with lazy execution?

[freerider7777]

To be closer to scala for :)

There are io.vavr.Api.ForXXX for Option, Try, List but there is not For for Either.

Also as for now I see that there is only "eager evaluation" (for example for Option) - all the arguments get executed, it's useless as we don't want to call the second function if the first fails.

[pivovarit]

Sounds good - targeting v0.11

[freerider7777]

when is 0.11 coming?

[pivovarit]

trying to not overpromise: this year

[freerider7777]

chat bots give some examples for lazy execution :) seems to work fine, maybe needs polishing:
like:
For(f1(), (r1) -> f2(r1), (r1, r2) -> f3(r1, r2), (r1, r2, r3) -> resultingFunction(r1, r2, r3))

public class EitherForComprehension {

// For 2 steps с yielder, which also returns Either
public static <L, R1, R2, R> Either<L, R> For(
Either<L, R1> step1,
Function<R1, Either<L, R2>> step2,
BiFunction<R1, R2, Either<L, R>> yielder) {

return step1.flatMap(r1 ->
    step2.apply(r1).flatMap(r2 ->
        yielder.apply(r1, r2))); // flatMap вместо map!

}

// For 3 steps
public static <L, R1, R2, R3, R> Either<L, R> For(
Either<L, R1> step1,
Function<R1, Either<L, R2>> step2,
Function<R2, Either<L, R3>> step3,
Function3<R1, R2, R3, Either<L, R>> yielder) {

return step1.flatMap(r1 ->
    step2.apply(r1).flatMap(r2 ->
        step3.apply(r2).flatMap(r3 ->
            yielder.apply(r1, r2, r3)))); // flatMap!

}

// For 4 steps
public static <L, R1, R2, R3, R4, R> Either<L, R> For(
Either<L, R1> step1,
Function<R1, Either<L, R2>> step2,
Function<R2, Either<L, R3>> step3,
Function<R3, Either<L, R4>> step4,
Function4<R1, R2, R3, R4, Either<L, R>> yielder) {

return step1.flatMap(r1 ->
    step2.apply(r1).flatMap(r2 ->
        step3.apply(r2).flatMap(r3 ->
            step4.apply(r3).flatMap(r4 ->
                yielder.apply(r1, r2, r3, r4))))); // flatMap!

}

@FunctionalInterface
public interface Function3<T1, T2, T3, R> {
R apply(T1 t1, T2 t2, T3 t3);
}

@FunctionalInterface
public interface Function4<T1, T2, T3, T4, R> {
R apply(T1 t1, T2 t2, T3 t3, T4 t4);
}
}

[pivovarit]

Actually, Copilot produced something that's not absolute garbage :) still not going to use it. To solve this, we need to generate methods that don't accept raw monadic types, but functions instead

So, for example, besides the existing:

public static <T1, T2> For2Option<T1, T2> For(Option<T1> ts1, Option<T2> ts2) { ... }

we'd also need to supply:

public static <T1, T2> For2OptionLazy<T1, T2> For(Option<T1> ts1, Function1<T1, Option<T2>> ts2) { ... }

then we could go from:

 Option<Integer> o1 = Option.of(2);
 Option<Integer> o2 = Option.none();

 String result = For(o1, o2)
   .yield(Integer::sum)
   .toString();

to:

 Option<Integer> o1 = Option.of(2);
 Option<Integer> o2 = Option.none();

 String result = For(o1, r1 -> o2) // r1 is the value of o1
   .yield(Integer::sum)
   .toString();

That would allow skipping the evaluation of r1 -> o2 if o1 is empty

---

Technically speaking, lazy evaluation is already supported through a deeply-nested For pattern relying on Iterable's For, but I believe there's room for improvement (so no need to wait for a new version to get lazy semantics)

for (Integer result : For(o1,
  r1 -> For(o2).yield(f -> r1 + f))) {
    System.out.println("result = " + result);
}

Either is already supported:

Either<String, Integer> e = Either.right(42);
Either<String, Integer> e2 = Either.left("foo");
Either<String, Integer> yield = For(e, e2).yield(Integer::sum);

[pivovarit]

#3085 this looks like the ultimate solution @freerider7777