I just saw the email announcement of

value class

and it sounds like something Arrow would be really interested in (immutable classes that have mutators that return copies). Do you have plans to use these features? They seem to clash with Lens, but maybe they could work well together?

Hello. Is there a way to transform an

Either

such that if

Left

meets some specific condition (i.e. filter out some error code that should not throw an error) the downstream Either via the fold operation gets routed to

ifRight

? I did something like this (where Either<List<MyErrors>, <Data>>):

return someService()
            .map { it.toEither().mapLeft {
                it.filter { it.code != "some-failure-code" }
            } }

But all that does in return an empty list of MyErrors to the downstream fold’s isLeft.

is there Cont Monad in arrow-kt?

Hello, I just started to use arrow and I have some problems with the following code based and the validated example. I got this nicely working with the either monad (without the Rules class) but I would like to understand how to get rid of the fix and flatMap calls here and how to make this work for the accumulate strategy. Since validated is just a monoid flatMap would be not an option in that case, right ?

fun validate(
   p: Player,
   i: Idea.OpenIdea,
   members: Eval<NonEmptyList<Member>>
): Either<NonEmptyList<ValidationError>, UnvalidatedPlayer> {
   return (Rules failFast {
       UnvalidatedPlayer(p, i)
           .let {
               it.accountNotLocked(TeamDbRepository)
                   .flatMap { it.notMember().fix() }
                   .flatMap { it.hasEnoughSkills().fix() }
                   .flatMap { it.notTooManyUnfinishedIdeas().fix() }
                   .flatMap { it.budgetLimitNotReached().fix() }
                   .flatMap { it.suitableDepartment(TeamDbRepository).fix() }
                   .flatMap { it.skillsInLimit(members, TeamDbRepository).fix() }
                   .flatMap { it.teamNotComplete(members).fix() }
                    .flatMap { it.cantAddAgain(PlayerRepository).fix() }
           }
   })
}

When using Arrow with Android, how would one pass an instance like Either via an Intent, since Intent requires the Either to be Serializable or Parcelable?

It seems that a class that is annotated with @optics can not be internal ? Is that true ?

Hey y'all, I saw that arrow now uses suspend functions to represent side effects, but I haven't found anything about the reasoning. Is it a marker? So if you call an impure suspend function, your function is now impure and thus must be suspended? (edit: marker, not sentinel)

Hey! Can anyone help me? Is there any way to run something like IO in in infinity loop with conditional exit? And if answer is tailRecM(), then can you explain how it works internally? Does it use lazy evaluation, or just build sequence until meet condition, and then run it?

What is

cancelBoundary()

(in the last example of https://arrow-kt.io/docs/integrations/kotlinxcoroutines/) ?

Hi, dependency question: so to just work with the new effect-system (basics like either-computations using suspend functions, not the scheduling and concurrent API), I need to depend on

arrow-fx

and not necessarily on

arrow-fx-coroutines

? (0.12-SNAPSHOT)

I'm struggling with a case where I can have multiple kinds of errors. For example for one operation I could have NetworkError, EncryptionError and a GenericError (fallback for everything else uncovered by the other two). In other case I might have just NetworkError. I use Either to wrap the result. Left is used for errors, right for the success value. My question is is there a way I can specify that the left can be an arbitrary number of types (known at compile time)? Like Either can be Left or Right, is there something for more cases?

I see code like this in our codebase:

}.mapLeft { throw it }

(on Either<Throwable, A>). Is this or should be part of the lib? I can't find out what rethrow() does, if it it is the same. Or something like getOrThrow.

Realizing the answer may be “Don’t get yourself into such a situation.” I’m wondering if there’s a way to convert an

Either<A, Either<A, B>>

into an

Either<A, B>

(Sorry for the basic question)

I can tell you

0.12.0

and

0.13.0

are coming really soon 😅 We're in the last 5% but you know how those go we don't have to explain to each other 😂

Let's say you have a algorithm function that acts like a pure function. This algorithm takes alot of time to compute, and thus adding suspend is normally recommended. However, in arrow world, suspend means that the function causes side effects, while this function doesn't at all (it is still pure, just takes alot of time). What should one do here?

If i want to perform an effect full operation like storing in a database, how could be the signature of the method I have an idea that is :

suspend fun killSession(): Either<LowUnprotectedError, Unit>

use void to represent the the effect full operation but feels wear, i think should be a better way to represent this kind of operations

What is the best way to run 2-3 different tasks in parallell (giving Either as result) with Arrow, i.e. it is not a list of equal operations?

My goal is to use Arrow in a java project at our company ‘Salesforce’ How can I use Kotlin Function type as a Data type within Java? For example: I have a typealias 

typealias _Validator_<_ValidatableT_, _FailureT_> = _suspend_ (_ValidatableT_) -> _Either_<_FailureT_, Any?>

Within Kotlin, I use it like this as a data type to assign to a lamda 

val validateParent3X: _Validator_<_Egg_, _ValidationFailure_> = {...}

But I cannot use typealias from Java. What is the idiomatic way to use this Function type as data type on Java? I see two unknows I have for java interoperability. 1. How can I idimotically refer a Function type 2. Function type being 

suspend

it isn´t able to resolve it

I'm fond of FP, but every time I think about adopting it into my backend project I find no practical use of it. Obviously, I mean advanced topics which are solved by Arrow, not standard Kotlin FP tools like

data classes

, high order funcs and etc. Any comprehensive open-source project (preferable Kotlin+Spring) which heavily uses Arrow (core, optics) you could recommend to dig in?

Non-FP Kotlin makes easy uses of

require()

,

check()

and

error()

to shortcut execution. Either is much more “precise” and “safe”, however I don't know how to write something as concise and readable:

fun foo(param: Int) {
  require(param > 1) { "Some message here" }

doSomething() ?: error("that's not possible")
}

I guess the

either

block should help with this, but I don't really see how to use it for these cases.

What is going to happen now that JCenter is dead like doorknob? Is Arrow going to move to Maven Central?

Hey guys, I'd like your advice on an issue I'm facing. So I have a screen that does an API call and shows a spinning wheel while the call is happening. All my API calls are represented as suspend functions. If I leave this screen while the call is ongoing, and come back to it, I would expect the spinning wheel to still be there, until the call is over. Alternatively, if I open another screen that depends on that same API call, I'd expect it to also show a spinning wheel, and update itself when the request comes back. In order to achieve this I need to, somehow, keep track that the call is out, and subscribe to its result rather than triggering a new call. With a non-functional approach, I would simply have a Flow in my repository and have multiple screens subscribing to it. But I don't want to do that cause it's smells like the kind of side-effects I wanna avoid. What is the best to go about this? Thanks!

👋 Hello! I've been using some functional programming languages like erlang/elixir/Clojure and recently started working at a company that uses Kotlin on the backend. Most of the code already makes use of (custom) Option/Maybe/Either types but I'm looking to take things a step further and make the database interactions more functional, probably using Arrow, but I don't know where to start. I'm assuming I need something like IO/Reader but is there any tutorial/blogpost/video that goes over this using Arrow? Any suggestions?

Hi! I’ve been playing around with Validated, and based on advice here, wrote a simple little function that will return a ValidatedNel based on a single validation rule:

suspend fun String.parseAgeString(): ValidatedNel<ValidationError, Int> =
        this.parseToInt().mapLeft{ Nel.just(ValidationError.InvalidAge) }

But I’m having a hard time trying to figure out how to chain additional validation rules---say we have a Valid value but it has to be greater than 18 or it returns another distinct ValidationError.

nothing too long, it’d be like

fun (Traverse<F>, Applicative<G>, Kind<F, Kind<G, A>>).sequence(): Kind<G, Kind<F, A>> =
  traverse(::it)

Is support for KSP planned?

Hi, is

Validated.mapN(Semigroup.nonEmptyList(), ...)

gone in 0.12 snapshot ?

I'm thinking about getting "_Functional Programming in Kotlin - Sustainable code with Kotlin and Arrow" by_ Vermeulen, Bjarnason & Chiusano. But I fear that learning about IO and things that will be deprecated in the upcoming Arrow releases ,just to forget about them, will leave me confused. Would you recommend reading it anyways?