Hi, I'm playing a bit with the computation blocks;...

# arrow

[HieiJ]

Hi, I'm playing a bit with the computation blocks; I'm trying to understand what is the best way to compose blocks for nested monads. As an example:

val str1 = "hello".toOption().right()
    val str2 = "world".toOption().right()

    val output: Either<Any, Option<String>> = either {
        option {
            val value1 = str1.bind().bind()
            val value2 = str2.bind().bind()
            value1 + value2
        }
    }

I'm wondering if there is any "generic" way compose in order to obtain (for this example) an eitherOption { } block where I can call .bind() just one time. I know that Option and Either nested like this are not so useful, this is just for having a simple example 😃

[simon.vergauwen]

With Multiple Receivers we can just do the following:

context(EitherEffect<E>, OptionEffect)
suspend fun <E, A> Either<E, Option<A>.bind(): A = bind().bind()

[simon.vergauwen]

Performance wise there is no penalty since it just uses inline fold underneath the hood

[simon.vergauwen]

It’s currently not possible to defined that in Kotlin, unless you do some manual wiring

[simon.vergauwen]

The only way to do this currently is to define:

interface EitherOptionEffect : EitherEffect<E> OptionEffect {
  suspend fun <E, A> Either<E, Option<A>.bind(): A
}

Which you can make concrete by doing something likee

[simon.vergauwen]

suspend <E, A>. optionEither(f: suspend EitherOptionEffect<E>.() -> A): Either<E, Option<A>> {
  either<E, Option<A>> {
    option<A> {
      f(object : EitherOptionEffect<E>,
           EitherEffect<E> by this@either,
           OptionEffect by this@option { })
    }
  }
}

[HieiJ]

Ok, Thank you @simon.vergauwen, I got it