hi, I see

Option

is deprecated in 0.11. What's the migration path for functions that I was calling on

Option

(specifically

traverse

and

foldMapM

) - is there an import that will make them available on nullable types or anything like that?

Hi, I’m struggling to think of a good way to combine

Either

with

Flow

when the flow can emit values before coming across something that should cause failure. For example:

fun getNumbersThatAreNotEleven(n: Int): Either<ThatsElevenException, Flow<Int>> = 
  flow {
    for(i in 1..n) {
      if (i == 11) {
        // sacrilege, what do I do here?
      } else {
        emit(i)
      }
    }
  }

I am writing a test for a method whose implementation starts with

parTupledN

, it works if i use

runBlocking

to run the the test but not with

runBlockingTest

. Would be nice if its made possible.

Hello! Can anybody show me, how to implement a functions that does an operation on a List given a function that does the operation on a single item in the context of IO and Either?

fun delete(account: EmailAccount):  IO<Either<DatasourceFailure, Int>> {
	// Implemented
}


fun delete(accounts: List<EmailAccount>): IO<Either<DatasourceFailure, Int>> {
	???
}

I'm quite new to FP and the given documentation it is almost impossible to get the hang of it without having already done FP in another language.

I folks, testing this

either<Error, List<String>> {
  remote.findByTerm(term)
}.mapLeft { NetworkError }

does not catch the exception, mock is configured in this way using mockito-kotlin

given { runBlocking { remote.findByTerm(any()) } } willThrow { RuntimeException("BOOM!") }

if I use

Either.catch{}

the exception is captured correctly and not propagated, is that the intended behavior?

Hi, I'm trying to model api responses that can be either successful with a specific type of data, network/server errors with throwables, or an api error with a specific type of data. I want to only write the code handling network and server errors once, so I thought I could do something like

sealed class Error<T> {
    data class Network(val throwable: Throwable): ApiError()
    data class Server(val throwable: HttpException): ApiError()
    data class Api(val response: T)
}

fun register(email: String, password: String): Either<Error<RegisterError>, AuthTokens>
fun login(email: String, password: String): Either<Error<LoginError>, AuthTokens>

I thought that would let me keep Error.Network and Error.Server the same everywhere, and substitute in different Error.Api's for different responses. The problem is that apparently Kotlin generics don't work like that. I would need to do

sealed class Error {
    data class Network(val throwable: Throwable): ApiError()
    data class Server(val throwable: HttpException): ApiError()
    data class Api<T>(val response: T)
}

fun register(email: String, password: String): Either<Error, AuthTokens>
fun login(email: String, password: String): Either<Error, AuthTokens>

So I lose the ability to specify what kind of Error.Api I return. Is there a way to avoid this?

@raulraja @Rachel why do we have type

Nothing

in this:

fun <A> absurd(): (Nothing) -> A

, but not

Unit

? https://github.com/arrow-kt/Category-Theory-for-Programmers.kt/blob/master/src/main/ank/1.5-products-and-coproducts.md Like it is written in CTfP book: "In the category of sets and functions, the initial object is the empty set. Remember, an empty set corresponds to the Haskell type Void (there is no corresponding type in C++) and the unique polymorphic function from Void to any other type is called absurd" So

Nothing

in Kotlin is the initial type for everything else?

Hello world 😅! .. I wanted to start learning arrow can anyone recommend where I should get started from , plus also if could suggest some commonly used arrow operations that everyone uses in their workflow would be great help.

I want to convert an

Either<SomeError, SomeSuccess>

to a

SomeError?

, discarding the SomeSuccess. Does a function like that exist in arrow? Right now I'm just doing the below, but I wanted to know if there is a more idiomatic way

return when (result) {
            is Either.Left -> result.a
            is Either.Right -> null
        }

Hi, I‘m currently migrating a project from IO to fx coroutines. It looks like everything works fine, but using

evalOn

(with any pool) seems to cause a deadlock in the IntelliJ debugger. This happens with both the whole application in debug mode and a single function in a test. Is there a wrapper or entry point I missed in the docs?

Hi, so I included

implementation("io.arrow-kt:arrow-optics:0.11.0")

but my project doesn't seem to find the generated (where?) companion object functions. I am using a gradle project with IntelliJ and an "@optics" annotated data class ... do I have to include arrow-meta too ?

Hmm, looks like Either's flatMap is not conforming to Scalas wrt. left type: https://arrow-kt.io/docs/apidocs/arrow-core-data/arrow.core/flat-map.html vs https://www.scala-lang.org/api/2.12.0/scala/util/Either.html#flatMap[AA%3E:A,Y](f:B=%3Escala.util.Either[AA,Y]):scala.util.Either[AA,Y] Scalas left just needs to be AA >: A, whereas in ArrowKt it needs to be the same.

Hi, I'm trying to rewrite

IO

code

val func = IO {
    println("some effect")
}
func.retry(arrow.fx.Schedule.recurs(IO.monad(), 3))

into coroutines but I can't find

retry

function which works on

suspend () -> Unit

. Does it exist or what's the alternative? Thanks

either { }

is already a monad transformer because it allows suspend functions inside 😱

Hi all! I'm trying to define a function that will be called every hour, and I was looking into the arrow Timer, but can't figure out how to define it.. do you know where I can find any examples for Timer? Thank you!

Guys,  I had started a library last year to have a wrapper over Jackson for a type safe programming. Please have. a look at it, remarks are highly appreciated and. if you believe it can. be taken further please help to contribute https://github.com/sahlone/kson

Hi, I have a question about definition

suspend fun <A, B, C> retryOrElseEither(
  schedule: Schedule<A, B>,
  fa: suspend () -> A,
  orElse: suspend (Throwable, B) -> C
): Either<C, A>

Why is input of

schedule

type

A

instead of

Throwable

? I'm trying to use it but I can't figure how

Hi, is is possible to force optics generation for kotlin data class I don't own (it has companion object)?

Wrote this today 🙂 any feedback more than welcome 🙏 https://jorgecastillo.dev/tracking-side-effects-with-suspend

and they all remain compatible with Either

Is there a function like

Either#merge

in Scala - an extension on

Either<A, A>

that returns

A

? Shall I PR one?

In your documentation on Validated under 'Improving the validation' you have the following example:

val parallelValidate = Validated.applicativeNel<ConfigError>()
    .tupledN(v1.toValidatedNel(), v2.toValidatedNel()).fix()
    .map { (a, b) -> /* combine the result */}

This example works, but it works only for values that are not optional?, so the current implementation is rather useless as you will not have Forms with every field mandatory (or Object with only mandatory fields when you create an instance in map {...} after validating each field. Should I consider this as a bug and report it or how would I validate a bunch of fields where some of them can be null?

is there an

option { }

continuation for nullable types similar to

either {}

?

Hi! There was an article in this channel about how to replace IO or Observable, or Async with arrow fx. Something in context of continuation and suspend-functions

I was reading over the changes in https://github.com/arrow-kt/arrow-fx/pull/169 and was curious what the approach for error handling would be. Is the general approach to use something like this at any boundaries to exceptional libraries:

suspend fun load(): Either<DomainError, DomainResult> = effectCatch(::errorHandler) {
    loadDomain()
}

I had used IO and used handleErrorWith to translate errors at my applications boundaries, but perhaps this is cleaner to mostly remove exceptions from my domain?

when I do this for example :

return either { 
    MyDomainObject.left().bind()
}

IDE shows me this :

Returning type parameter has been inferred to Nothing implicitly. Please, specify type arguments explicitly to hide this warning. Nothing can produce an exception at runtime.

on v0.11.0 with arrow-fx-coroutines.

I just saw Option is deprecated as it is promoting bad coding style. However I'm curious are there really more downsides than upsides to make that decision. What's the experience with it? It was very useful for filterMap (what will the alternative be in this case?) and when using RxJava, where nu values are not allowed