I'm facing a simple task, but struggle to solve it elegantly. (To clarify: performance is not an issue). I have two

Set<X>

collections, and I want to see if they contain equal items. The challenge is that this equality must be tested by some external

isomorphic

function (which takes two arguments of type

X

) instead of the standard equality operator. Can someone point towards helpful ideas or tools in Kotlin/Arrow?

Greetings. Assuming I have:

Map<Int,List<ONE>>
Map<Int,List<TWO>>
...
Map<Int,List<N>>

Is there any "instrument" I can zip it to

Map<Int, Tuple<ONE,TWO,...,N>>

where ints represent unique numbers which present in each Map?

Hi everyone! I'm trying to do something like this with only Arrow Core

Option.fromNullable(nullableValue).mapNotNull(::f1).flatMap(::f2)

where f1 is

suspend (String) -> String?

and f2 is

suspend (String) -> Option(Whatever)

, is this supported?

Hi everyone, I added Arrow on my KMP project and used it in the commonMain part. When I use the generated framework/aar, I’m experiencing some NoClassDefFoundError Either.kt in the android application (iOS run without any problem), if I add the Arrow dependency on android I solve the problem but asap will be rise another NoClassDefFoundError for a simple kotlin file inside the project, did somebody have the same experience or know where I should check to solve the problem?

Hi everyone, I was looking over the differences between suspended computation blocks and the eager variant, and my intuition is that the eager variant is not pure. E.g.

either {}

vs

either.eager {}

. I admit that I didn’t fully understand the implementation for the eager variants. Is my assumption correct? Would this be an important argument for using the suspended variant?

When using bind inside either blocks, to simulate a failure, I sometimes do MyError.left().bind(). This leads to compiler warning me like :

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.

What are the implications of this, apart from readability that

MyError.left().bind()

is not clear in what the RHS can be. iirc, its not trivial to remove these errors, they can only be suppressed. Is there any work being done in fixing this ? Also,

MyError.left().bind()

is this recommended approach ? I often use filterOrOther to avoid warnings.

Trying to remember one video about Functional Programming, but can't. Maybe you can help. So this was some kind of conference, seems like in 00's or early 10's and a man was showing Functional approaches in writing UI programs. He was combining different shapes and surfaces for rendering a simple 3D object(sphere for example) in his GUI.

Hi everyone, I had a use case recently where I had to return left in an either if the right value was not null. So I ended up writing an extension function for that:

inline fun <E, B> Either<E, B?>.leftIfNotNull(f: () -> E): Either<E, Nothing?> = flatMap { it.rightIfNull { f() } }

Is there something that might have helped in Arrow and I've missed it?

Hei ! I can’t find the thread back, so I’ll ask again. Why CancellationException is considered as Fatal error, and thus not being caught in Either.catch ? Since my operations inside bracketCase are wrapped in Either, I have to explicitly catch CancellationException, to rollback my transactions on ExitCase.Cancelled

I’m looking for a method to do

List<ValidatedNel<E, A>>

->

ValidatedNel<E, List<A>>

, is there any such method? 🙂

Let's say I have 2 classes A & B, with fields of the same name but different types. For each field I have an Iso from one type to the other. Is there an easy/concise way to turn those into an Iso<A, B>?

Hey guys, I have a question regarding Arrow Fx: how stable is it (will the API change/be deprecated)? Is it production ready in terms of quality?

Hello all! Are there any other suggested resources for understanding the Arrow library, or the concepts used within? Many of the terms (function names and class names) are foreign to many new to the functional world. A high percentage of the functions/classes and usage are not documented. It seems there is an assumption of previous knowledge to utilize the libraries. Is there another documentation source from another library that perhaps this pulled its ideas from (Scala?) for those new to functional programming understand what these mean and are use for? I've been trying to move a team forward but it's just to difficult to be bombarded with so many questions due to the lack of resources, and the team has already pulled back and are devolving back to old habits.

Hello, I’m updating to latest version of arrow, I have a problem with one method. What’s the equivalent of this method using latest arrow version, thanks in advance.

/**
 * Given a path as string dot-separated component, extracts the item found at that path location.
 * Eg.:
 * Given m = mapOf("p1" to mapOf("p2" to "value_1_2"))
 * Then m.readPath("p1.p2") -> Option["value_1_2"]
 */
inline fun <reified T> Map<String, Any>.readPath(pathComponents: String): Option<T> {
    val extract = { v: Any, p: String -> (v as? Map<*, *>)?.get(p).toOption() }
    return pathComponents.split(".").foldM(Option.monad(), this, extract).fix().flatMap { (it as? T).toOption() }
}

I love the NonEmptyList class of the arrow-core library. It statically ensures the presence of at least one element. What do you think about introducing a NonEmptySet class extending the Set interface? Haskell seems to have an equivalent too.

I have upgraded to arrow 1.1.2, and switched from

either

to

Effect

. I like it BTW, it is a nice abstraction IMHO. But I have some issues. It is a multiplatform project and issue might not be related to Arrow, but it emerged once I switched to

Effect

. It looks related to

native

target(s) only. More in the thread …

Are there any release notes or announcements for 1.1.0/1.1.2 releases?

Is it safe to use

1.1.2

for now, coming from a pure jvm-project, or should I wait for the official announcement and release blogpost before updating? 🙂

Hi, I have a problem to use Arrow in my JS project. I took the versions from the sample project (https://github.com/arrow-kt/Arrow-JS-Template) and I get a compiler error when building. Has anyone experienced this before and has any idea how I can fix it. The sample project can be built and also runs in the browser.

is there a way to generate arrow lenses at compile time without annotating the class? I want to use arrow just for my unit tests and no arrow deps in main sources.

Can we optimize this

futureOr

function:

suspend fun fu(i: Int): Boolean = TODO()
    suspend fun futureOr(fs: List<Int>): Boolean =
        fs.parTraverse { fu(it) }.reduce { acc, b -> acc || b }

Now it needs to wait for all of suspend function completed. But we know that if there is one of the

fu(it)

return

false

we can return

false

and cancel the rest. Not sure how to do it nicely here.

can i combine 2 lensen to something that sets and gets 2 values?

Hi all. Question regarding Either and Exception handling. Given we still live in an imperfect world that’s not fully functional, there often comes a time in a program when you need to bridge between the functional parts of your program and imperative parts that still rely on Exceptions being thrown to manage control flow. I find myself leaning on an extension function that looks like this:

fun <A,B> Either<A, B>.throwException(f: (A) -> Unit): Unit = when (this) {
    is Either.Left -> f(this.value)
    else -> Unit
}

which I then use like this:

val someResult: Either<SomeErrorADT, String> = ...
someResult.throwException { 
  when (it) {
    SomeErrorADT.Error1 -> throw SomeException1("...")
    SomeErrorADT.Error2 -> throw SomeOtherException("...")
  }
}

Is there an existing function or extension function that exists in Arrow that kind of does the same thing that I’m not seeing?

Using

Schedule

to repeat an operation. Is there a way to get the delay after adding jitter to the schedule. Better yet, is there a way to get how much time has elapsed since the start of the schedule.

Schedule.exponential<SomeResult>(someConfigDelay)
            .jittered()
            .whileOutput { it < someConfigMaxDelay }
            .logOutput { log.debug("Current delay: $it - ${it.inWholeNanoseconds} ns") }

I’ve been finding myself using this recently:

internal infix fun <A, B> Resource<A>.flatTap(resource: (A) -> Resource<B>): Resource<A> =
    flatMap { a -> resource(a).map { a } }

which allows for constructs such as

fun CoroutineScope.myProcessor(database: Database) = resource {
    MyProcessor(coroutineContext, database)
} release {
    it.close()
} flatTap {
    resource { it.backgroundWorker() } release Job::cancel
}

Effectively allowing for similar usages as

tap {}

but with a teardown/release.

Hei. I wonder if we arrow has wrappers on collection apis to always return Nel instead of List. For example nonEmptyListOf(1, 1).distinct() will always be non empty, but because of kotlin apis, i get back List. This is uncomfortable. to ensure I am working with an nel, I often end-up converting list to nel. It would’ve been nice to not do that.

I think I’m encountering a bug in

Resource.parZip

when `parZip`ing a `parZip`’d resource 🙂

suspend fun main() = int(1)
    .parZip(int(2), Int::plus)
    .parZip(int(3), Int::times)
    .use { println("using $it") }

private fun int(n: Int) = resource {
    n.also { println("acquiring $it") }
} release {
    println("releasing $it")
}

outputs

acquiring 2
acquiring 1
acquiring 3
using 9
releasing 3

and never releases 1 and 2

Hi all. Is there a good “Pet Store” example application that anybody could share, one that shows an opinionated view of when and how to use the various Arrow types (or not)? I.e. an application that actually performs a more real-life like business function? Possibly one that’s maintained by the maintainers of the Arrow library itself? Surely there are assumptions/expectations of how the various APIs should be used when they are authored, so I’d be curious to see more on that. I think it would be helpful when getting started. I browsed all the repos in the Arrow Github org and nothing stood out. Thank you!

@simon.vergauwen it seems like the new

resource { }

DSL releases resources in the wrong order - see 🧵