Never used Arrow before but trying to improve my error handling and excited about Railway Oriented Programming. To keep it practical, how do you model your http request response with Arrow? I've seen something "Use

Try

in data layer, then map to

Either

for domain". Am I on the right track? Any good hands-on articles, like "Retrofit + Arrow, error handling"? Thank you.

the Arrow Meta talk will start soon!

I'm trying to port RemoteData to Koltin, any feedback is welcome 😄 https://gist.github.com/effe-megna/e84f5fb313daa6c5484cc07f02813bbe#file-remotedata-kt

@Francesco megna it’s more broken than we thought

use flatMap(::identity) for now

Hi guys, I’m working with coroutine and Either and I faced a problem with the flatMap of either.

suspend fun findLocation() = coroutineScope {
        locationDelegate.checkSettings().flatMap {
            locationDelegate.getLocation()
        }
    }

In this sample, I can’t call

locationDelegate.getLocation()

since the

getLocation()

is a suspend function. How can I handle suspend functions in

flatMap

since it is not an inline function?

what is the most FP arrowy kotlin redux that ppl in here like?

Hi - sorry for the shameless plug but we are looking for a Senior Android Developer here at Permutive in London - pm me if you are interested or would like more information. Someone with Arrow experience would be a great fit (we are using Arrow to a certain degree in our Android platform & we use Scala Cats/Http4s on our servers & Haskell, too). You can get the details here: https://apply.workable.com/permutive/j/F5DC7F5054/

Is there something like

IO

(lazy, safe, etc.) that does not use

Throwable

for the error type? My main issue is that

IO.raiseError

needs a

Throwable

and in my use case, constructing a stacktrace is too expensive.

any hint?

Silly question, is there a concise way to force an expression to have Unit return value? Eg, sometimes the last thing I want to do in an IO block is log something, but Android Log.* methods return integers for some reason not described in the API documentation. I feel silly adding an extra line just for "Unit" to fix the return type.

you might usually want some form of

.void()

function for any

Functor

that does nothing more than

Functor.map(it -> ())

Still you can use

Either.catch

but really you should be using IO if you are dealing with effects

how do you plan to integrate nullables? is there some open discussion thread to have an idea of how it will look like?

so there will be fewer

fix()

and

sequence(Either.applicative())

needed all around. Ideally not at all 🙂

Somebody should write a book about arrow-kt 🙂 and with FP intro. It is really hard for someone to just jump in and learn arrow without proper explanations and good examples of idiomatic usages. I would buy that book right away 🙂

if you're in a suspend function you have

Either.catch { }

which accepts suspend functions inside too

A question about the

operator fun invoke

in `Either.Left`: why is it there? It looks like a constructor but I can't think of a case where the behavior would be different from just making the constructor public instead. It made sense for kategory when

Either.Left

had two type parameters so you wouldn't have to specify the

Nothing

type explicitly (https://github.com/JcMinarro/kategory/blob/master/kategory-core/src/main/kotlin/kategory/data/Either.kt#L125), but why does arrow have it too? (https://github.com/arrow-kt/arrow/blob/master/modules/core/arrow-core-data/src/main/kotlin/arrow/core/Either.kt#L818). For that matter, why did

Either.Left

ever have two type parameters in kategory?

https://github.com/47deg/helios/blob/master/helios-parser/src/main/kotlin/helios/parser/Parser.kt this looks like an arrow-kt json parser. I'm not yet sure what im looking for to understand how this diverges from a kotlin minimal effort.

@Jannis do you have a haskell -> jvm bytecode emitter?

IO::bracket

works well when you have something like this:

IO { take a resource safely }.bracket(release = { give it back }, use = { use it in a way that can fail })

but what about the case where taking the resource can also fail? Is there a method that can handle this, or do I need another

bracket

?

according to the paper (https://functorial.com/the-future-is-comonadic/main.pdf) from which i guess it was implemented:

4.2 Day Convolution

Another common pattern is to display two user interfaces

side-by-side, with their states evolving independently.

A comonad to specify such an interface would again need

to store all future states of both components, and we would

also need a function to render any two current states. This

data is captured by the Day convolution of the

two functors

you may also want to do a PR against the libraries site

I'm trying to build arrow-kt project, forked from github, and i have this error

A problem occurred evaluating project ':arrow-meta'.
> tools.jar not found at your JAVA_HOME dir /Applications/IntelliJ IDEA <http://CE.app/Contents/jbr/Contents/Home|CE.app/Contents/jbr/Contents/Home>.
  Building with a JRE or JDK9 is currently not supported.

Free has the issue in Kotlin that interpreting multiple algebras is not fast as the number grows, we fixed that for Scala in Freestyle but Free + Coproduct doesn't make a lot of sense in Kotlin until we have true union types

To improve propCheck's output I wrote a small pretty-print library. It's nothing special yet, but the basics are there. It's pretty early work, but I don't think there are any other pretty print libraries for kotlin so if you need one give this a try, it's gonna improve fast the next few days. Internally in propCheck I have a parser that can read generic toString (especially data classes toString) output, diffs that and displays it using this. https://github.com/1Jajen1/kotlin-pretty