I’m seeing something rather weird with the

result {}

computation (arrow 1.1.3, kotlin 1.7.20, but also occurs in 1.6.21 at least). Notably, if you switch dispatcher within the computation as follows:

result {
    withContext(<http://Dispatchers.IO|Dispatchers.IO>) {}
    1
}

you end up with nested

Success(Success(1))

, despite the return type being correctly

Result<Int>

. Weirdly, using the following in it’s stead

private suspend inline fun <A> result(crossinline f: suspend ResultEffectScope.() -> A): Result<A> =
    effect { f(ResultEffectScope(this)) }.toResult()

Works as expected, but looks to be identical in implementation. I’ve also realised I still have no idea when best to use

runCatching {}

vs

result {}

vs

Either.catch {}

😳

What's the current stability status of Arrow Core for multiplatform projects?

When writing a function whose sole purpose is to check some invariant, is it best practice to declare it as:

EffectScope<Failure>.() -> Unit

or:

() -> Either<Failure, Unit>

I think the first one is clearer that "it's just validation code", what do you think? Is there any official recommendation? The first one also doesn't need the user to call

bind

, which they may forget since there is no proper result.

Hey, I’m trying to use arrow optics on Kotlin Multiplatform I have a Multiplatform module with JVM only, I’ve added the Ksp plugin and

kspCommonMainMetadata(libs.arrow.optics.ksp)
add("kspJvm", libs.arrow.optics.ksp)

then I’ve added

kotlin{ 
  sourceSets.all {
    kotlin.srcDir("build/generated/ksp/${this.name}/kotlin")
  }
}

and I see the code generated under • generated/ksp/jvm/jvmMain/kotlin • generated/ksp/metadata/commonMain/kotlin But the generated code is not resolved I believe I’m missing something in the setup (?)

hi! is anybody coming to the Kotlin Dev Day happening in Amsterdam by the end of the month? and if so, would you be interested in an “Arrow meetup” the day before (23 november)?

Hi, just stumbled upon https://arrow-kt.io/docs/analysis/ and I’m in love with the idea 🙂 However, just gave it a test drive and it fails on some trivial cases. Please see the thread

Hello, I’m experimenting with Optics, and I have something like

playerFlow.map { player ->
  val firstNameLens = Player.name.first
  firstNameLens.set(player, "John")
}

If I want to modify also the last name, is there a nicer way than this?

playerFlow.map { player ->
  val firstNameLens = Player.name.first
  val lastNameLens = Player.name.last
  val a = firstNameLens.set(player, "John")
  lastNameLens.set(a, "Doe")
}

if I get Category Theory for Programmers Scala edition. How transferable will the concepts of the book be to Kotlin?

hi, is it possible to have a exponential jitter retry schedule that has a whileOutput and a untilInput condition? It seem that only the last one configured wins in the chain.

val exponentialBackoff: Schedule<Throwable, Double> = Schedule.exponential(TimeUnit.SECONDS.toNanos(2L).toDouble())

val retrySchedule = exponentialBackoff.jittered()
                    .whileOutput {
                       TimeUnit.NANOSECONDS.toSecods(it.toLong()) < 10.0
                    }
                    .untilInput { 
                        when (it) {
                             is ApiException -> it.statusCode in 400 until 500
                             ...
                             else -> false
                        }

the above never stops on the whileOutput condition (using this at work and don't have the code handy, it looks at least similar to above :D)

This message was deleted.

Will Arrow implement Typeclasses? or does that have to come from the language?

Would it make sense to add support for graph data structures inside arrow? It's something I would love to help with but probably too large to handle as a personal project. Expressing graphs in a monadic way is something I haven't stumbled upon yet but it sounds exciting.

fun mytimer() = Schedule.forever<String>().delay { duration ->
    Duration.Companion.seconds(5)
}

Hi all, What is the input argument 'duration'.. when has it a value other than 0s (in this example it is always 0s) ?

Is this the right channel to ask about arrow-inject? I have a question about its planned capabilities, and some conceptual hurdles that I ran into trying to implement something similar. (Also has the repo been moved to arrow-proofs?)

Question about arrow-proofs: I can see that polymorphic proofs are a thing, so how do you deal with a proof like

Foo<Foo<T>> -> Foo<T>

? That proof is valid in that it's not cyclical, but if you're working backwards from knowing that we need a

Foo<T>

then I can't see how to ascertain that this proof isn't applicable (because the proof is applicable if e.g. there's a

Foo<Foo<Foo<T>>>

that can be created). One can obviously look at other proofs that provide a Foo of something and use those as a starting point, but what if there's a proof

Bar<T> -> Foo<T>

and the only proof returning

Bar<T>

requires a

Foo<Foo<T>>

(akin to mutual recursion) Also will arrow-proofs support something like

@Inject fun <A, B> test(@Given bar: Bar<A, B>, @Given foo: Foo<A>): B = bar.someFunctionThatTakesFooAndReturnsB(foo)

As in, will type parameter be properly substituted in like that and allowed to influence the resolution of what proof to use for

foo

, or will the caller have to specify

A

and

B

for the call to resolve correctly? Looking around the plugin code I can see that for every

Inject

function you generate one with default arguments, so I can't really see how this use case could be supported.

I wanna generate arrow-optics lens for data class by using plugin https://arrow-kt.io/docs/optics/lens/#generating-lenses It makes lens variable well, but Android Studio can not find the variable

@optics
data class Company(val name: String, val address: Address) {
	companion object
}

// Auto generated code

public inline val com.example.contextreceiversample.Company.Companion.name: arrow.optics.Lens<com.example.contextreceiversample.Company, kotlin.String> inline get() = arrow.optics.Lens(
  get = { company: com.example.contextreceiversample.Company -> company.`name` },
  set = { company: com.example.contextreceiversample.Company, value: kotlin.String -> company.copy(`name` = value) }
)

public inline val com.example.contextreceiversample.Company.Companion.address: arrow.optics.Lens<com.example.contextreceiversample.Company, com.example.contextreceiversample.Address> inline get() = arrow.optics.Lens(
  get = { company: com.example.contextreceiversample.Company -> company.`address` },
  set = { company: com.example.contextreceiversample.Company, value: com.example.contextreceiversample.Address -> company.copy(`address` = value) }
)

I tried to reference

Company.name

, but Android Studio can not find it. Still, build and run normally. How can I solve this problem? I had tried

Invalid Caches and Restart

.

I’m starting to upgrade a few services from arrow 1.0 to 1.1. It seems that

either

and

either.eager

are now deprecated? The replacement is

effect { … }.toEither()

and

eagerEffect { ... }.toEither()

? Is that right?

So ive been using atomicfu for atomics for a while, is there a difference in performance how they work or any benefits /downsides to arrows atomics compared to atomicfu?

looking to do a transformation of arrow types, but having trouble coming up with a succinct call chain. i have a

List<() -> Validated<E, A>>

which i want to transform into

ValidatedNel<E, A>

by: 1. specifying invalid value if the list is empty 2. calling items until the first valid value is encountered 3. aggregating invalid values until (2) 4. ignoring items after (2) i can come up with an "ugly" way to do this easily enough, but i'm curious if there's a nice fluent pattern for it. thanks in advance!

Hi, i need to execute meterService.incrementExitRequests(“online”) always, no matter if there is an error. Is there anything in arrow that works like a finally clause? Not sure if it is the correct approach.

either<ReservationError, Unit> {
    //do some logic
}.mapLeft {
    meterService.incrementExitError("online")
    it
}.map {
    meterService.incrementExitRequests("online")
}

I'm looking to do something pretty simple: I have a boolean expression, if it evaluates to

true

, I want to evaluate something and return it as a

Some

, otherwise I want to return a

None

. Here's a pretty trivial implementation that might be clearer:

fun <A> Option.Companion.cond(condition: Boolean, value: () -> A): Option<A> = if (condition) {
  value().some()
} else {
  None
}

Is there anything built-in that I'm missing?

With the existing operators/constructors, I probably could implement a "on/off" switch only, when that switch is evaluated in the function that is passed to

repeat

(think

AtomicBoolean

or something similar). So the Schedule actually continues, but the effect to be run by

repeat

has to evaluate that switch inside it's own logic. What I am looking for is something like an

pause

operator, which completely stops the Schedule until some condition gets true again. Is this semantic possible with the current operators somehow or could that be added in the future ?

Has anyone looked at teaching arrow analysis how to keep track of composition local usages in function body’s to imply the required composition locals. Then i’d imagine the call site of a function could be validated? I’ve not ever used the tool but it seems like the sort of thing it could do after listening to the kotlin talks conversation. For those not working in android land: https://developer.android.com/reference/kotlin/androidx/compose/runtime/CompositionLocal You can sort of think of comp locals as an implicitly available map to pull things from.

Hey. I have a very "stupid" problem, sorry 😅 So I'm using Arrow with spring boot, and I'm having problems with deserializing Options and Eithers (haven't tested other data types). It seems to be converting the inner state into JSON instead of the "value". I feel like I'm doing something incredibly stupid here. Any hints? I've put more details here with a minimal working example https://github.com/arrow-kt/arrow-integrations/issues/105

Hello, looking for some guidance as I am new to Kotlin coroutines/arrow. To get better, I am planning on doing advent of code 2022 using arrow coroutines. To start, I solved last year's day one here: https://github.com/chiroptical/advent-of-code-2022/blob/main/src/main/kotlin/dayOne/DayOne.kt. First, does this look reasonable? I am mostly curious about my approach to

CoroutineScope.windows

and

dayOne

(there are edge cases in

strictlyIncreasing

that aren't important for this conversation). Second, is it possible to fold in parallel as well? I tried creating two actors, passing inputs to them, and then combining them at the end but it just didn't do anything. I am incredibly open to suggestions here🧵

Just wanted to say, I'm always impressed by the Arrow documentation every time I read it. It's really a new standard for the entire ecosystem.

For arrow 2.0 will Option be deprecated?

Is there a relationship between the Arrow core type

Effect

and the

arrow-fx

projects? I've been using

Effect

to model effects such as calls to a database or web service. Is there a recommended way to use the features of

arrow-fx

to add retries to an

Effect

?

Is there a detekt/findbugs for Arrow? I sometimes forget to bind my Eithers and I'd like the build to fail next time I do it