Hi arrow folks, I'm currently working on the FP in...

# arrow

[marc0der]

Hi arrow folks, I'm currently working on the FP in Kotlin chapter that deals with Monads 🎉 I've gotten to a point where I can't really express what I want to in Kotlin, and was hoping that Arrow could help me out here!

[marc0der]

Specifically, I am trying to declare a monad instance for a data type that has two type parameters, namely State<S, A>. We can get around this in the short term by specifying a monad instance that is tied to s specific implementation, in other words declare an `IntState<A>`:

[marc0der]

val intStateMonad = object : Monad<ForIntState> {
    override fun <A> unit(a: A): IntStateOf<A> =
        IntState { s: Int -> Pair(a, s) }

    override fun <A, B> flatMap(
        fa: IntStateOf<A>,
        f: (A) -> IntStateOf<B>
    ): IntStateOf<B> =
        fa.fix().flatMap { a: A -> f(a).fix() }
}

[marc0der]

This has the side-effect that State<S, A> needs to extend from IntStateOf<A>. Fine, but when we introduce a new member to the state monad family, say doubleStateMonad , we are now constrained in that State<S, A> cannot also extend from DoubleStateOf<A> as well! Even if we could, having to keep extending our base data type doesn't scale very well.

[marc0der]

Scala allows us to declare type lambdas to get around this problem by giving us flexibility at instantiation of such a monads anonymously:

[marc0der]

def stateMonad[S] = new Monad[({type f[x] = State[S,x]})#f] {
  def unit[A](a: => A): State[S,A] = State(s => (a, s))
  def flatMap[A,B](st: State[S,A])(f: A => State[S,B]): State[S,B] =
    st flatMap f
}

[marc0der]

Sorry for the long-winded explanation 😄, but is there a way to express something like this with Arrow? And if not, some handy workaround for such situations where multiple type parameters exist?

[raulraja]

This can probably be solved using StateTPartial

[raulraja]

What doe the final Scala encoding look like in the example for this chapter? I can try to type to Kotlin

[marc0der]

@raulraja I was looking at that in the source code, but couldn't find any examples or documentation regarding how to use this.

[raulraja]

Something important to mention in the monad chapter is also delimited continuations since they subsume all monads

[raulraja]

In whatever case it should be doable, and yes there is no examples because we don't promote MTL style since there is usually better alternatives

[marc0der]

The final example in the original book is the one I pasted above for stateMonad[S]. I realise that we won't have something like the type lambdas available, but any help here with a workaround would be super appreciated.

[simon.vergauwen]

@marc0der ({type f[x] = State[S,x]})#f this loosely translates to an anonymous function at the typelevel which creates a type for State which partially applies S.

If we say that Kind<F, A> == F[A], Kind2<F, A, B> == F[A, B] and so on. We can say that Kind is constructor at the typelevel, which takes F and applies A to it.

The trick however is that `Kind2<F, A, B> == Kind<Kind<F, A>, B>. So you can partially apply type arguments.

In you case you want to apply S to ForState.
So ({type f[x] = State[S,x]})#f is the equivalent of:

typealias StatePartialOf<S> = Kind<ForState, S>
Where A can be applied by doing Kind<StatePartialOf<S>, A> == Kind2<ForState, S, A> == State<S, A>.

[simon.vergauwen]

Now you can partially apply S to StatePartialOf<S>, and apply A in map.

interface StateMonad<S> : Monad<StatePartialOf<S>> {
  fun <A, B> Kind<StatePartialOf<S>, A>.map(f: (A) -> B): Kind<StatePartialOf<S>, B>
}

[simon.vergauwen]

That’s the technique we use in Arrow.

Instances Reference: https://github.com/arrow-kt/arrow-incubator/blob/master/arrow-mtl/src/main/kotlin/arrow/mtl/extensions/statet.kt#L55

Where StateTOf is an alias for Kind3<ForState, F, S, A>.

HKT boilerplate:
https://github.com/arrow-kt/arrow-fx/blob/master/arrow-fx/src/main/kotlin/arrow/fx/IO.kt#L64

[simon.vergauwen]

Hope that helps 👍

[simon.vergauwen]

But as Raul mentioned it’s a pattern we’re not actively promoting, since there are other ways of doing things in Kotlin.

Replace Reader/Kleisli with extension functions.
https://gist.github.com/nomisRev/1f91710ebec1709d4ce8059812482624

Or combining suspend with Either
https://github.com/arrow-kt/arrow-fx/tree/master/arrow-fx-coroutines#suspend----eithere-a

[marc0der]

@simon.vergauwen thanks for your help! This looks like exactly what I'm after, I'll give it a try when I get a chance later on. I'll ask if there is anything else I'm unclear about.

[marc0der]

I hear you both about mtl, but the original book simply uses this as an example of what the meaning of a monad holds, not as a recommended approach. I'll certainly make mention of the other approaches too.

[simon.vergauwen]

Glad I was able to help!

[marc0der]

@simon.vergauwen I just implemented this and it works a treat. Thanks again for your help!

[simon.vergauwen]

You’re very welcome! 🙂