Just double checking; there is no new

arrow-fx-coroutines-kotlinx-coroutines

artifact because there is no more need for suspendCancellable because Arrow Fx Coroutines is now compatible with cancelation from Kotlinx Coroutines?

Hi! I do not understand the behaviour of https://arrow-kt.io/docs/apidocs/arrow-core/arrow.core/kotlin.collections.-iterable/compare-to.html (0.13.1). The following applies:

listOf(1, 0, 0) > listOf(0, 1, 1) == true
listOf(0, 1, 0) > listOf(1, 0, 1) == false

Looking at the implementation I understand how this is computed but I believe this is a bug. I am not quite sure, since I do not understand how the compareTo-operator should work on lists but right now the whole outcome is determined by the comparison of the elements at index 0. And If two values at the same position are equal then the whole outcome is determined by the comparison at the next index unless the equality occurred at the end. At least to me it seems like it was not intended to work this way.

Hi, does @optics work with internal classes. It seems arrow meta is by default generating public classes. I am trying on 0.13.1.

Should there be a difference in result between

traversEither

on a List vs a Nel or am I using it wrong? If I run below Kotest code, The Nel one ends up with 4 elements (the head gets repeated at the end of the list)

"Test traverseEither on list" {
        val t = listOf(1, 2, 3).traverseEither { i ->
            i.right()
        }

        val list = (t as Either.Right<List<String>>).value
        list shouldHaveSize 3 // true [1, 2, 3]
    }
    "Test traversEither on NEL" {
        val fromList = Nel.fromListUnsafe(listOf(1, 2, 3))
        val t = fromList.traverseEither { it.right() }

        val list = (t as Either.Right<List<String>>).value
        list shouldHaveSize 3 // false [1, 2, 3, 1]
    }

Just caught up with the thread of

traverseEither

on Nel. The behavior of traverseEither on Iterable was also different than what I expected. It walks the sequence from back to front and also

f

is evaluated on all elements even if a Left value is found.

Hi all, great work and congrats on 0.13.1! 🥳 I'm just upgrading some of our code, and stumbled on a workaround we had done from last September for Option support in jackson. ... has this been added back in as part of 0.13.1?

Any update on Kotlin Multiplatform support? It's not in 0.13 right?

Hi 🙂 Are there plans to replace the arrow-fx durations with kotlins duration in arrow (used e.g. in Schedule)? 🙂

Hi, I wonder if anyone can help me with a question on how to create a pipeline of transformation functions. Some of the functions return the type that is being operated on directly, and some functions return Either. Below is a contrived example of what I am trying to achieve. The part that I do not like is having to give a name to the intermediate values (i1, i2, etc). If they all returned a simple value (rather than some functions returning either), I could use 'andThen' to compose the functions together. Sorry for the simple question, but I struggle with how to accomplish stuff in a functional way sometimes.

public suspend fun test(): Unit {
    val add1: (number: Int) -> Int = { it + 1 }

    suspend fun divideBy(number: Int, divideBy: Int): Either<Throwable, Int> {
        return Either.catch { number / divideBy }
    }

    val result = either<Throwable, Int> {
        val start = 1
        val i1 = add1(start)
        val i2 = !divideBy(i1, 2)
        val i3 = add1(i2)
        add1(i3)
    }

    result.fold(
        { println("failed: ${it.message}") },
        { println("result: $it") }
    )
}

Is there an equivalent to comprehension pattern for Reactor’s publisher similar to this

MonoK.fx {
  //comprehension block
}.value()

that we use to be able to do in Arrow 0.11.0 in Arrow 0.13.x?

Semantically speaking, which is more idiomatic?

Either<Error, Result>

with an associated

NotFound

error type or

Either<Error, Result?>

Hello! 👋 I am trying to upgrade our app from 0.11 to 0.13.1, and it seems

parTupledN

and

parMapN

has been moved and is now deprecated. Is there documentation on how I could resolve this? Thank you!

Hi 👋 , another migration question from

0.11.0

to

0.13.1

. How would I write this function now:

suspend fun buildPerson(): Either<DomainError, Person> {
    val name: Either<DomainError, Name> = getName()
    val address: Either<DomainError, Address> = getAddress()
    val dob: Either<DomainError, Date> = getDOB()
    return Either.applicative<DomainError>().tupledN(name, address, dob).map {
        Person(name = it.a, address = it.b, dob = it.c)
    }
}

Follow-up: Can I accomplish this in parallel (assuming

get*

function are

suspending

)?

Hi! Can anybody tell me how to refactor this:

Validated.applicativeNel<Failure>()
        .tupledN(
                Validated.fromEither(valId).toValidatedNel(),
                Validated.fromEither(valName).toValidatedNel(),
                Validated.fromEither(valDescription).toValidatedNel(),
                Validated.fromEither(valEmail).toValidatedNel(),
                Validated.fromEither(valFrom).toValidatedNel(),
                Validated.fromEither(valAuthenticationId).toValidatedNel(),
                Validated.fromEither(valUrl).toValidatedNel(),
                Validated.fromEither(valSettings).toValidatedNel(),
                Validated.fromEither(valProperties).toValidatedNel()
        )
        .fix().toEither()

Hi! in the process of migrating to 0.13.1, I have come across a serious refactor,

interface BankGateway<F> {
    fun bankAccounts(): Kind<F, Result<List<Bank>>>
}

the final implementation is ForIO, which means that, do I have to rid of it and use suspend everywhere?

This talk was the root of all evils. I was very proud to have built an application abstracting it from the final implementation, now all is suspend hahaha Now I can say that arrow allows you to build the same in a more simple and idiomatic way

Hello :-) What is the new way to do something like:

val someList = ...
val someListOfIOs = someList.map { IO { ... } }
someListOfIOs.sequence(IO.applicativeError())

Now that IO is gone (and sequence is deprecated)? 🤔 Image I have a list of items, and want to do some side-effect actions for each, but want to short-circuit everything when the first fails.

Look at traverseEither. But be warned there's an issue if the list is an Nel.

Hey friends, is it reasonable to run suspended functions within an IO? We're migrating from

IO

to

suspend

and wondering about interoperability. E.g. in this example,

myFun()

works as expected, despite

log(..)

being a suspended function. I believe this is because

IO

now uses

suspend

under the hood?

import <http://arrow.fx.IO|arrow.fx.IO>
import kotlinx.coroutines.delay

suspend fun log(message: String) {
  delay(1000)
  println(message)
}

fun myFun(): IO<Unit> = IO {
  log("test")
}

myFun() // does nothing, suspended
myFun().unsafeRunSync() // logs "test"

How can I do applicative traverse collecting failures on left hand side ? it was possible in 0.11.0 if I remember correctly, but I can’t seem to write it in the new version. from

List<A>

to

Either<List<B>, List<C>>

just like we do for validated We only have parTraverse and parTraverseEither. So I can either get

List<Either<B, C>>

or

Either<B, List<C>>

Hi all, could someone provide me with an example on how to use Validated? Thanks.

Hi, let's say I'd want to use

either { ... }

computation in a conventional (non-reactive, controller endpoints are not suspend!) Spring Boot RestController (for validation + effect-short-circuiting) ... what are my options: runBlocking, or some other recommended 'bridge to suspend-world' ? Obviously this concern could become obsolete if mainstream actually moves away from 'blocking Spring', but what recommendations (if any specific exist) are there until then ?

Shameless plug... In case someone missed it 😄 https://www.47deg.com/blog/functional-domain-modeling-part-2/

Hey guys, hope you doing good! Currently i`m working on code coverage of some functions using cooroutines, my problem is that i dont know how to cover those lines that launch coroutines like:

runBloking {}

Another question that may you guys could help me. I’m working on a functionality that fetch a list of users and validate each to know if it need to be deleted or not. I have 2 methods. first one is to fetch users

fun getUsers(max: Int): Either<LowUnprotectedError, List<User>>

and the other one is the validate method

fun isCandidateToDelete(user: User): Either<LowUnprotectedError, Boolean>

. Then i need to star the process for each user, but given the method to validate the user is in a Either, I need to fold it in order to know the result of verification like this :

val usersDelete = users.filter { repository.isCandidateToDelete(it).fold({ false }, { it }) }`

Could you imagine a better way to accomplish this process. Please let me know if i was not clear with this question, thanks in advance!!

What is the correct way to transform an

Iterable<Either<L,R>>

into a

Validated<Nel<L>, R>

? For more context, I’m using parTraverse on a collection, returning an

Either<L,R>

for each item. I’d like to collect that into a

Validated<Nel<L>,R

to that I can take the left path if there are any errors and collect that into some useful log message. It looks something like

items
  .parTraverse { doWork(it, foo) }
  .toValidated() // This is what I'm trying to figure out.
  .mapLeft { makeErrorMessage(it) // where it is Nel<L> }

fun doWork() : Either<L,R>

I see there is a

traverseEither

for

Map

, is there a

parTraverseEither

? This is what I have right now:

val items = // Map<K,V>
val newUrls = items.entries
  .parTraverseEither { (key, value) -> doWork(key, value).map { Pair(key, it) } }
  .map { it.associate { (first, second) -> first to second } }.bind()

class DownloadStructure(val name: String, val link: String, val size: Int) { fun fmap (f: (String) -> String): DownloadStructure = DownloadStructure(name, f(link), size) } // why this would cause class Redeclaration error?

What is the current suggestion to replace tupled ?