sorry, I know this is more of a Gradle question about work-in-progress 😄... but is arrow-fx-stm (SNAPSHOT) available in some maven repository or do I have to clone and build it locally ? ..because: this seems so much more intuitive than setting up e.g. channels, events, actors etc. ! https://arrow-kt.io/docs/next/apidocs/arrow-fx-stm/arrow.fx.stm/-s-t-m/index.html

(unrelated) if kind is going away then how are traverse/sequence/etc. implemented in the new version?

I'd like to share this very good news here: https://youtrack.jetbrains.com/issue/KT-28056 https://youtrack.jetbrains.com/issue/KT-28055 ...these seem to have arrived in the latest 1.30M1 Kotlin-Release and relate to the possibility to have inline-classes with initialisation, which should be good news to all validation- and DDD-ValueObjects afficionados 😉

Was wondering if anyone could recommend a forum to discuss functional approaches to specific real-world problems using kotlin & arrow? As a concrete example, I’m playing around with a little side-project, and trying to figure out how to do OAuth token refresh in a “pure” way, or at least to move the “impure” behavior to the periphery of the system. Can anyone recommend an appropriate Slack channel for discussing such “meat & potatoes” things?

Which non-blocking http client do you typically use in your apps with arrow-kt?

Hello, I'm trying to learn how best to leverage Arrow core and fx. My days are typically spent working on long running servers. This normally means something like the following managing the lifecycle of the service:

import java.lang.Thread.currentThread
import java.lang.Thread.sleep
import java.util.concurrent.CountDownLatch
import kotlin.concurrent.thread

fun main() {
    val mainThread = currentThread()
    val shutdown = CountDownLatch(1)

    Runtime.getRuntime().addShutdownHook(thread(start = false) {
        println("Shutdown triggered...")
        shutdown.countDown()
        mainThread.join()
        println("Shutdown completed!")
    })

    println("Starting...")
    sleep(1000) // bootstrap long running resources (e.g. DB Connection, HTTP Server, HTTP Client)
    println("Started!")

    shutdown.await()

    println("Stopping...")
    sleep(2000) // graceful shutdown (i.e. request long running resource to stop)
    println("Stopped!")
}

I'm wondering how the above translates to Arrow fx.

Hi folks, sorry to ask what I’m sure is a fairly simple question, but I feel like I’m missing something fundamental here. I’m trying to implement a simple client that uses OAuth, and that will handle expected “failure” cases like, for example, refreshing expired access tokens. To cut to the point, how can the handling of the right vs Left cases in this code be streamlined further? Surely checking isRight is an anti-pattern? 🙂

Hi, I've noticed the

Either::catch

is no longer suspend function and I'm curious what is the reasoning behind that change? I thought the reason was to denote it as a side effect, since throwing is a side effect. That I presume didn't change 😄

I’m looking for some example of arrow

State

I have an object (

Customer

) that has his current status as a enum val , I wanna model the posible change from a state to next (as in a state machine pending->...-> review —> onaboarded) and I think using this type is the right way but can’t find a good example

the nullable case not compile 😅 :

Exception in thread "main" java.lang.AbstractMethodError: Receiver class com.acv.composeland.ui.arrow.ArrowKt$nullable$2$1 does not define or inherit an implementation of the resolved method 'abstract java.lang.Object invoke(com.acv.composeland.ui.arrow.Either, kotlin.coroutines.Continuation)' of interface com.acv.composeland.ui.arrow.NullableEffect.

at com.acv.composeland.ui.arrow.ArrowKt$main$composition2$1.invokeSuspend(Arrow.kt:75)

at com.acv.composeland.ui.arrow.ArrowKt$main$composition2$1.invoke(Arrow.kt)

at com.acv.composeland.ui.arrow.ArrowKt$nullable$$inlined$suspended$1.invokeSuspend(Effect.kt:25)

at com.acv.composeland.ui.arrow.ArrowKt$nullable$$inlined$suspended$1.invoke(Effect.kt)

at arrow.continuations.generic.SuspendMonadContinuation.startCoroutineUninterceptedOrReturn(SuspendingComputation.kt:88)

at arrow.continuations.Reset.suspended(Reset.kt:27)

at com.acv.composeland.ui.arrow.ArrowKt.nullable(Arrow.kt:88)

at com.acv.composeland.ui.arrow.ArrowKt.main(Arrow.kt:74)

at com.acv.composeland.ui.arrow.ArrowKt$main$2.invoke(Arrow.kt)

at com.acv.composeland.ui.arrow.ArrowKt$main$2.invoke(Arrow.kt)

at kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt$createCoroutineUnintercepted$$inlined$createCoroutineFromSuspendFunction$IntrinsicsKt__IntrinsicsJvmKt$1.invokeSuspend(IntrinsicsJvm.kt:205)

at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)

at kotlin.coroutines.ContinuationKt.startCoroutine(Continuation.kt:115)

at kotlin.coroutines.jvm.internal.RunSuspendKt.runSuspend(RunSuspend.kt:19)

at com.acv.composeland.ui.arrow.ArrowKt.main(Arrow.kt)

Is there a

Function1

equivalent for suspending function / coroutines? https://arrow-kt.io/docs/0.10/apidocs/arrow-core-data/arrow.core/-function1/index.html

Monad#fx.monad

is deprecated - apparently

fx

will be directly on the concrete datatypes? What does this mean for custom monadic datatypes - do I need to do anything to let me write

fx

blocks with my custom monad?

Hi. Did I understand it correctly, that Arrow will get rid of the

fix()

calls? I just saw this and wondered, how it's going to look then. Thx and have a nice weekend.

Hey All, I came across a fascinating with @raulraja and @simon.vergauwen on youtube: Arrow FX: Functional Domain Modeling with Kotlin. Was wondering a) is there an associated github repo? I’m having a difficult time figuring out things like i.e. required dependencies for the @Refinement annotation, etc… and b) are there more videos like this that show idiomatic Arrow being applied to real-world applications? Thanks!

Hi! I'm trying to test some IOs with delays, but get some

IllegalStateException: This job has not completed yet

. Here's a basic example, could you tell me what I'm doing wrong ? Thanks

@Test
    fun test() = runBlockingTest {
        IO.effect { delay(10000) }.suspended()
    }

Imagine actually not preparing a salad irl for lack of 5 grams of lettuce 😄 Taken from https://arrow-kt.io/docs/patterns/error_handling/ Hope you'll forgive the lighthearted offtopic.

I wonder why Ior.flatMap need to be passed a Semigroup<A> and sequence an Applicative<G>. Why isn't it just finding a "typeclass" og that type for A and G? (.semigroup() and .applicative())

What is the recommended way of doing parallell processing with Arrow now? Kotlin's async? I see parTraverse gives IO, which I though would be replaced by coroutines/suspend now?

Hi! I'm wondering why either{} is a suspend function. I read above, that Either::catch is no longer a suspend function and would like to know if the same is true for either {...} For me that is one of the biggest flaws of Arrow as Either is a central concept and I always have to cope with suspend even when most of the code is pure.

how to use

Either

and

Validated

together?

Either

for fetching and

Validated

for validating data. I have code that parses some data and then I need to perform some check on that data to determine is it valid or not. parsing function return

Either

because parsing can fail and I want to validation function to return

Validated

based on validation logic

Hello everyone, how would you best model the

Either<SomeFailure, Unit>

case? Say I have to set something and don’t care about the result? We found out the hard way that having

Unit

in there could be a potential problem since the compiler does not oblige us to see inside. thanks

Is the best monad sequence syntax (as of 0.11.0) still something like:

Option.fx {
    val (a) = Some(1)
    val (b) = Some(1 + a)
    val (c) = Some(1 + b)
    a + b + c
}

🔈Hello everyone!, There is currently some internal discussions as to what to call the monad operator in Arrow for the 1.0 series. We plan on introducing a single version for this going forward in 0.12.0 and would love your feedback as to what style you prefer. We would love your help in helping us decide by voting in one of the following options: 1️⃣ bind

either {
  val a = funThatReturnsEither().bind()
  val b = eitherValue.bind() 
}

2️⃣ invoke

either {
  val a = funThatReturnsEither().invoke() //explicit
  val b = funThatReturnsEither()()  //implicit 
  val c = eitherValue()
}

3️⃣ not

either {
  val a = !funThatReturnsEither()
  val b = !eitherValue
}

4️⃣ other and opinions: (reply in a thread to this message)

Hi! I'm following the ArrowAndroidSamples example. There we have the following code:

fun <F> Runtime<F>.loadNews(): Kind<F, List<NewsItem>> = fx.concurrent {
    val response = !effect(context.bgDispatcher) { fetchNews() }
    continueOn(context.mainDispatcher)

    if (response.isSuccessful) {
        response.news().toDomain()
    } else {
        !raiseError<List<NewsItem>>(response.code().toNetworkError())
    }
}.handleErrorWith { error -> raiseError(error.normalizeError()) }

I get a deprecation warning on fx.concurrent:

fx: MonadFx<F>' is deprecated. Overrides deprecated member in 'arrow.typeclasses.MonadError'. Fx will be moved to each datatype as a DSL constructor.

What is the correct way to handle this?

Hi everyone I remember reading some time ago that Arrow wanted to implement Union types, am I right? Is there something available in 0.12 version? More info about the usecase in the thread

Hi, I've never used ZIO before so maybe this is a silly question, but with

arrow.fx.coroutines.retry

the doc's say "The effect is executed once, and if it fails..." How does it determine failure with the effect? I've managed to achieve what I want with

repeat

and

schedule.doUntil { it.isRight() }

but it would make a little more sense to "retry a network request until is succeeds or fails 5 times" than to "repeat a network request until it succeeds or fails 5 times"

If i have an either:

val result: Either<VdsError, VdsData>

and these error data types:

sealed class VdsError {
    object NotFound: VdsError()
    object SystemError: VdsError()
}

is there a simple way to map on success, but also on

NotFound

, but break out of the mapping if

SystemError

? eg

result.map { data ->
    doSomething()
    data
}

basically conditionally map some failure circumstances but ignore others? I thought perhaps a conditional mapLeft would do this, but the problem is that

mapLeft

then returns a

Left

rather than a

Right

and then you immediately exit hope this makes sense, I'm still quite new to these sort of functional types.

hello, everyone is there a shorter/cleaner way to do the following

either1.fold(
        ifLeft = { it.left() },
        ifRight = { r1 ->
            either2.fold(
                    ifLeft = { it.left() },
                    ifRight = { r2 -> mapper(r1, r2).right() },
            )
        }
)

The left type of both eithers is the same. I want to call mapper() if both of eithers are

Right

. If one of them is

Left

, mapper won't be called. The result type is

Either<SameLeftType, ReturnedTypeFromMapper>

.

what's the new do-notation syntax for monads?