Could anyone answer this SO question <https://stackoverflow.com/questions/61530141/understanding-val...

# arrow

[Venkat]

Could anyone answer this SO question https://stackoverflow.com/questions/61530141/understanding-validated-applicative-in-kotlin-arrow-library

[stojan]

done 😄

[stojan]

https://stackoverflow.com/a/61530844/1011435

[Venkat]

@stojan oh thank you so. Let me give some time to read and understand your answer

[stojan]

no worries, let me know if you have doubts

[Venkat]

I can understand your tupled example clearly, but I couldn't catch how NonEmptyList combine function gets called implicitly when any of the value failed ?

[Venkat]

or what if change my lamda function from {a,b -> a+b} to {a,b -> a-b}

[stojan]

your function is only applied if both values are Valid

[stojan]

Semigroup.combine is applied if both are Invalid

[stojan]

which works by adding two lists

interface NonEmptyListSemigroup<A> : Semigroup<NonEmptyList<A>> {
  override fun NonEmptyList<A>.combine(b: NonEmptyList<A>): NonEmptyList<A> = this + b
}

[stojan]

or what if change my lamda function from {a,b -> a+b} to {a,b -> a-b}

then you get a different result (in case both are valid)

[Venkat]

so in my code map is equivalent to tuple in your example

[Venkat]

is it ?

[stojan]

yup, my happy path function is "hardcoded"

[stojan]

and actually, arrow also has tupled returning TupleN in case of success (as a specialization of map)

[Venkat]

fun <A, B, Z> map(
  a: Kind<F, A>,
  b: Kind<F, B>,
  lbd: (Tuple2<A, B>) -> Z
): Kind<F, Z> =
  a.product(b).map(lbd)

[Venkat]

fun <A, B> Kind<F, A>.product(fb: Kind<F, B>): Kind<F, Tuple2<A, B>> =
  fb.ap(this.map { a: A -> { b: B -> Tuple2(a, b) } })
fun <A, B> Kind<F, A>.map(f: (A) -> B): Kind<F, B>

[stojan]

here is a similar example for combining 2 values of type `Option`https://github.com/LordRaydenMK/fpscala.kt/blob/master/src/main/kotlin/chapter4/exercise4.3.kt#L6

[stojan]

well, the arrow codebase is abstracted over typeclasses, which can make the code harder to read (especially because typeclasses are emulated in Kotlin)

[Venkat]

😀 I just try to find the line that calls semigroup combine method

[Venkat]

anyhow thank you so much for your time

[Venkat]

ill accept your SO answer

[stojan]

You are welcome, I hope it helped 🙂

[Venkat]

fun <E, A, B> ValidatedOf<E, A>.ap(SE: Semigroup<E>, f: Validated<E, (A) -> B>): Validated<E, B> =
  fix().fold(
    { e -> f.fold({ Invalid(SE.run { it.combine(e) }) }, { Invalid(e) }) },
    { a -> f.fold(::Invalid) { Valid(it(a)) } }
  )

I think this applicative type class method doing the trick. ValidatedOf Datatype extends applicative typeclass method ap() which takes semigroup and combines invalid results as you said, but the fold function inside it looks weird.

[stojan]

Fold is how you interpret the type into a single value, providing functions for the Valid and Invalid case.

[Venkat]

Yep but here it takes two function for invalid (e ->) and two function for valid ( a->) case 🤔

[stojan]

you have two values of type Validated , (the implicit one, because the function is an extension function, and f ). And you need to unwrap both of them.

So again, like in my example you need to handle 4 cases.

[Venkat]

Ah understood 👍