I have a function which returns

IO<A>

, where

A

is some

enum

having 3 different states:

Complete

,

Error

and

CustomError

. I want to retry the function until either

Complete

is returned, or a duration exceeded condition is true. What is the best way to do that with

IO

?

Hi guys, I would like to know if there is any example of using Arrow and Kotlin flow ? I searched on the web and couldn’t find anything useful.

Another question that I have. What is the recommended way of doing dependency injection ? Based on my research, there is the Reader monad based on a article written by Jorge Castillo. There is also this with Francisco Garcia. And also in the arrow documentation, you can do it using Typeclass. What is the recommended way of doing dependency injection ? what are the advantages of one method over the other ? If this question is not asked to the right channel, feel free to redirect me to the correct one

Hey folks, I'm watching Scott Wlaschin's 2015 talk on Railway oriented programming. He mentions dead end functions which can be incorporated into a composition (tap and tee). Is there an equivalent in Arrow ... or is simply doing

.map { someOp(); it }

the approach?

@Rachel??

@starke @pakoito Would this cover the logic safely? https://github.com/mattmoore/kotlin-playground/blob/master/src/test/kotlin/io/mattmoore/kotlin/playground/arrow/comprehensions/OptionComprehensionSpec.kt#L14

Hi All, is there any way to remove the

.k()

as much as possible in the following example:

val m = mapOf("a" to listOf(1, 2).k(), "b" to listOf(3).k()).k()
val n = mapOf("a" to listOf(4).k(), "c" to listOf(5, 6).k()).k()
val p = MapK.semigroup<String, ListK<Int>>(ListK.semigroup()).run { m + n }

Hi All, another question: I'm using

Either

like this:

fun f(): Either<Exception, A> = try {
  // do something
  Either.right(a)
}
catch (e: Exception) {
  Either.left(e)
}

Is that the correct way to use

Either

? Is there anything more suitable than Either for that purpose (wrapping a value and catching all exceptions)?

Hello FP people 👋 I'm exploring applying FP/arrow across a micro service i'm building but I'm unsure what the best/right approach is in some areas. I've put together a short & simplified example which reflects my current thinking and I'd hugely appreciate any advice either 😂 in general but also specifically in terms of how to deal with the effects inside the Repo (should I use an Either, IO, Either.fx?!) and what that looks like?? I started looking at IO and .unsafeRunAsync, but the javadoc comment about never using it in production confused me as to how I actually get the block inside to execute?! Code snippet inside thread

How to convert this list

val eitherList: List<Either<Exception, String>> = TODO()

to a

List<String>

? Someone on StackOverflow (I think) suggested:

eitherList
  .filterIsInstance<Either.Right<String>>()
  .fold(emptyList()) { acc, right -> right.fold({ acc }, { acc + it }) }

Is there any better way?

I'm playing with functions. Here, the restriction I've set for myself is that f2 depends on f1 and f1 depends on E, but E must be supplied late, after the program has already been constructed. All that's fine, as far as it goes. I'm particularly interested in the function

f3

. It seems like there might be a named pattern for what it's doing. It kind of behaves like

partially

, except it defers the partial application till later. Then it partially applies to f2 the result of executing the deferred function (when that happens). If such a pattern exists, what's its name? Do helper functions already exist in Arrow to do this for me? Basically, is there a better way? Thanks much!

I'm half way through @raulraja's presentation to the Chicago Kotlin group and was curious when some of these features are available? Eg, from what I can tell

@Coercion

is not available now is it, if it is which package can I find it in?

modify that file and send a PR 😄

the destructuring one may fail for some types because of ambiguity on the compiler

Sorry another newb question. I've have several functions that are called serially and only return a concrete value if they fail ... i've tried representing them as Option<Failure> but I'm unsure how to construct the comprehension on None. Is there an easy way to do this, or should I be using Either? If Either, what type should I use on the Right (Unit?)?

@raulraja I was looking at this example of kotlin di that you wrote. I was wondering, if there was a requirement that

Module.data

or

Module.domain

be lazy evaluated, would there still be a way to have

Module

implement

Data

and

Domain

?

Oh dear for some reason I thought the Arrow Academy presentation was starting in 10 minutes. Opps! will it be posted?

Hi everyone. Quick question - do you have high-res pictures for your Arrow modules (Arrow Core/Fx etc) Needed for presentation :)

Hello, This is my first attempt with the new ArrowFx DSL 🙂 https://gist.github.com/PhBastiani/9e494f7fd971848296914c775f052cbe No error/cancellation handling at the moment. Not sure that my tailrecursive

copy

method is the most idiomatic. I noticed a wrong proposal of the IDE: sometimes IntelliJ proposes to remove the

suspend

modifier when it is necessary 😕 Feedback appreciated !

With

effectfulProgram: IO<E, A>

I could do

effectfulProgram.unsafeRunSync()

to run the program from a none suspended context. (For example an endpoint in a framework without coroutines.) Now I am trying out the new Arrow Fx Coroutines lib and transformed my program to

effectfulProgram: suspend () Either<E, A>

. How do I run it? 😅

What is the correct way to solve this?. Usually I make these functions inline so context is not lost

Where can I read up on Coercion Projection and Liquid Types ?

I have a use-case where I need to model objects that come from many different data sources, and they are not always the same. As a comparison, I could take calendar events. Some of my data sources let you subscribe to an event, some don't, but they all let you have a start/end date, etc. I think the ‘traditional' way would be something like:

interface Event {
  val start: ...
  val end: ...
  val canSubscribe: Boolean
  suspend fun subscribe()
}

But that's a lot of boilerplate per feature, and since I want to learn Arrow, I'm thinking there must be a better way. What do you think of:

interface Event {
  val start: ...
  val end: ...
  fun subsribe(): Either<UnsupportedOperationException, IO<Unit>>
}

Hi, regarding the (now merged) Arrow Fx Coroutines API, I would like to try it with 0.11.0-SNAPSHOT, specifically this monadic comprehension with Either:

suspend fun either(): Either<PersistenceError, ProcessedUser> =
  Either.fx {
    val user = !fetchUser()
    val processed = !user.process()
    processed
  }

.. so I added arrow-fx (SNAPSHOT) to my dependencies, but where does the bind-operator

!

come from ? IntelliJ doesn't seem to find it.

curious to hear other opinions of Arrow users on this one -> https://github.com/arrow-kt/arrow-core/issues/114

Hi, I wanted to get some feedback on the approach for getting an output of a function that returns

IO<Either<InvalidCommand, Command)>>

as an input to a function that takes

Command

as a parameter and returns

IO

return EitherT.monad<ForIO, DomainError>(IO.monad()).fx.monad {
      val (command) = EitherT(commandFrom(commandType, commandString))
      val (eventRecord) = EitherT(commandHandler.handle(command).map { it.right() })
      eventRecord
    }.value().fix()
      .map { result -> result.fold({ Response.Error(it.toString()) }, { Response.Success(it) }) }
      .unsafeRunSync()

Does this seem like the right approach?

I guess the types just switched places

inline fun <L, F> EitherT.Companion.monad(MF: Monad<F>): EitherTMonad<L, F>
inline fun <L, F> EitherT.Companion.monad(MF: Monad<F>): EitherTMonad<L, F>

Hi all, I'm stuck and hoping someone can point me in the right direction 🙏 . I"m trying to do something like this:

val numbers = listOf(1, 2, 3, 4)
val strings = numbers.map { somethingThatReturnsEither(it) }

// Here I'd like to map strings and put Lefts into one list and Rights into another list

return Tuple2(failures, successes)

Hopefully that makes sense. I could just do a forEach and put everything into lists manually, but I'm hoping there's an FP way here