Is there an existing utility/extension function that converts

R?

to

Either<L, R>

? Something like

fun <L, R> R?.toEither(f: () -> L): Either<L, R> {
    return Option
        .fromNullable(this)
        .toEither(f)
}

Try

IO.fx

Trying to build

arrow

, but have

Building with a JRE or JDK9 is currently not supported.

. Which one do I need? 11?

Do we have any public real-world examples of arrow usage? Like Android apps, etc. Especially interested in Fx, but since it’s relatively new, tagless-final style can work as well.

Learning FP with arrow... The more I understand its logic, the less I understand this one: why did we need OOP at all?!

Can't understand, why the brackets around

a

solve the compile-time problem:

binding {
  val (a) = IO.invoke { 1 }
  a + 1
}.fix().unsafeRunSync()
// 2

hey 👋 talk I gave on FP in kotlin went up I'm giving a similar talk soon, if anyone ends up watching it and has feedback for me I'd love to hear it.

let's say that in an android application i call the IO fx block, but the user moves to another screen before it is finished

hi, what import should I use when I want to use

val fx: Fx<ForIO> = IO.fx()

? from docs it should be

import arrow.effects.extensions.io.fx.fx

but

arrow.effects.extensions.io.fx

doesn't seem to exist. I'm using 0.9.1-SNAPSHOT

My SO account is RIP, could anyone please jump into this question? https://stackoverflow.com/questions/57153396/how-to-use-arrows-type-classes

Probably I'm not the first one: what about kotlin-arrow GSON retorfit converter which could convert Nullable types to Option?

clean up your build, should be fixed

I get that the call chain gets deep quickly recursing like that

T isn't a collection, so we don;t know where that prepend to comes from

That does worry me a little bit, the docs https://arrow-kt.io/docs/effects/fx/ indicate using

IO {...}

in conjunction with

effect {...}

but ^^ the example above gets to SOE pretty quickly when attempting to use the two together

and it does complain if I do something like

tailrec suspend fun factorial(n) = if(n == 1) { 1 } else { n * factorial(n - 1) }

I just remembered we did some fixes in IO related to stack safety but those aren't released yet either :/

Guys, i just can’t stop saying HOW AMAZINGLY this

suspend

plays with IO and FP. Did you write any papers about it already? I can see it as a contribution to the science

are you in 0.10 already?

if someone else would be to step up, I can mentor 😉

In fact there is someone who is already playing with these concepts and SwiftUI and it looks really nice

@Miguel Coleto What we noticed is that most (not all) of our mobile (Android) apps we make have very little business logic. That is all on the server. And business logic would be the prime target for coding it in FP. Most of the code deals with the ‘edge of the world’: UI/Services on top; Network, Cache, File, BLE, etc on the bottom. There is very little code in the middle: ViewModel and datasources (and some UI validation)

I am having some type inference issues in MTL.

import arrow.core.Id
import arrow.core.ListK
import arrow.core.Option
import arrow.core.extensions.id.applicative.applicative
import arrow.core.extensions.list.traverse.traverse
import arrow.mtl.Reader
import arrow.mtl.extensions.kleisli.applicative.applicative

interface Context
interface Topic
interface Result

typealias Job<A> = Reader<Context, A>

fun processTopic(t: Topic): Job<Result> = TODO()
fun processTopics(topics: ListK<Topic>) = // The compiler bails here
  topics.traverse(Job.applicative(Id.applicative())) {
    processTopic(it)
  }

Can someone help me out?

and follow the compiler’s suggestions

i have an android kotlin project that relies heavily on rxjava. as far as a kotlin projects go, it’s using a lot of FP constructs (stream manipulations, immutability is important, etc.) do you think throwing arrow-kt in the mix would be helpful? does anyone successfully use this combo?

Nice! If you want something really powerful I’d consider supporting unions/sealed classes

Hey since there aren’t stupid questions... Why does

foldRight

on

Either

make use of an

Eval<C>

?