Hi!. In this video (at the playback point on the link) an alternative way to model domain errors with extension functions and not requiring sealed / shared inheritance was hinted: Is that on any code example / talk done afterwards already? I’m experimenting with things there, but would like to know the approach suggested on the talk cause it may be better / different and it would be nice to see before choosing something.

If I have

val lens1: Lens<S, A>
val lens2: Lens<S, B>

how do I apply them one after another to change field

A

then change field

B

and return

S

?

fun modify(s: S): S {
  return lens1.modify { a.doStuff() } ?? lens2.modify { b.doStuff() }
}

i.e. I want not to compose them but to sequence them.

My talk from Droidcon Berlin where I talk about Either and Validated (Form Validation on Android) https://www.droidcon.com/2022/08/02/error-handling-beyond-the-standard-library/

Hi where am i going wrong? 🤦‍♂️

What is the advantage of using

either

over

either.eager

for suspending computations? If I use

either.eager

, will it simply block the current thread?

suspend fun doSomethingLong(): Either<Error, Unit>

either.eager {
    doSomethingLong() // does it block the current thread?
}

Hi I need some guidance on how to employ

Either

while completing related operations for example i am calling

retrofit

api calls then persisting the data into my local

sqlite

database i am employing

io.arrow-kt:arrow-core-retrofit

for my

retrofit

calls as follows:-

/**

* <https://api.discogs.com/artists/45467>

*

*/

@GET("artists/{artist_id}")

suspend fun artist(@Header(HEADER_AUTHORISATION) accessToken: String = ACCESS_TOKEN, @Path("artist_id") artistId: Long): Either<CallError, ArtistResponse>

then in my worker:-

override suspend fun doActualWork(): Result {

return repository

.artist(artistId = 45467)

.fold(

ifLeft = { callError -> consumeCallError(callError) },

ifRight = {

val artist = ARTIST_MAPPER.map(it)

println(artist)

repository.database.artistDao().insertAsync(artist)

Result.success()

})

}

how can "wrap" or employ Either for the code i execute in my ifRight block above? e.g. the database insert. As I am using Room and it does not accept Either type

Why are the monad comprehensions like

option

or

either

suspend functions? Wouldn’t they work just as well without suspend?

🧵 Hi all. Looking for some advice/review on this small

effect

inspired builder/DSL that I created to wrap calls to gRPC services. Details inside the thread.

is there something in Arrow that would allow me to define a

doSomething<T1, Tn, ..., Tn>(...)

that would output

On

In other words, if I provide 5 generics, I want an

O5<T1, T2, T3, T4, T5>

as output and if I define 1 generic, I want

O1<T1>

as output

I just tried integrating Arrow Analysis for the first time in our project. The compiler fails on:

Type alias SomeAlias should have a descriptor

...where

SomeAlias

is any Kotlin typealias that has a generic parameter (of several that we have in our project). Is Arrow known to not support generic type-aliases? Is there an annotation to suppress analysis for such types?

Hey.. Is there any good pattern for this use case? I have an API that returns an

Employee

for instance.. I want it to have non-null values for a lot of fields which actually are nullable in the underlying system. So I would like to have my client deserialize the API response into a

User

and then use a

toEmployee

method that returns a

ValidatedNel<Problem, Employee>

.. More in thread.

Speaking of validations, here's a small editorial and suggested changes to the Error Handling Tutorial to promote what I would consider a slightly better practice with regards to which return type to use for validation functions (

Validated

vs.

ValidatedNel

). The tutorial and most (or even all) examples I've seen on using the

Validated

type declare all validation functions using

ValidatedNel

type, even if the function only really ever returns a single error. For instance, a string field validation function that checks the length will either return a (single) length validation error, or the valid string, but the error is wrapped in the

Nel

. And the only reason I can think of is because when zipping the validated types together, one can simply do

val someEntity: Validated<DomainError, SomeEntity> = 
  validateField1()
    .zip(SemiGroup.nonEmptyList(), 
         validateField2(), 
         validateField3()) { (v1, v2, v3) -> SomeEntity(v1, v2, v3) }

i.e. not worry about dealing with

Validated

vs.

ValidatedNel

. I personally think the semantics are not accurate for these validation functions as we're false advertising that there could be multiple errors returned by each validation function. I think we should use the

Nel

type when the function can truly return multiple errors, otherwise you should stick with

Validated

. When zipping all your validated types together, it's really trivial to "sprinkle" a little

toValidatedNel

here and there to then accumulate all the errors together:

val someEntity: Validated<DomainError, SomeEntity> = 
  validateField1SingleError().toValidatedNel()
    .zip(SemiGroup.nonEmptyList(), 
         validateField2MultipleErrors(), 
         validateField3SingleError().toValidatedNel()) { (v1, v2, v3) -> SomeEntity(v1, v2, v3) }

Really nitpicking here, but I'm just curious to get other people's thoughts. Thanks!

Second small comment regarding the Monad Comprehensions tutorial. We may want to update the examples as I noticed it uses the now deprecated

arrow.core.computations.either

object as opposed to its replacement

arrow.core.continuations.either

.

And last question on validation: are there plans to introduce comprehensions for the

Validated

datatype? Or is it not possible? I think it would make composing validation functions easier.

Apologies if the last 2 comments are already known issues/suggestions. Thanks!

Hi! I am trying to model the error handling in our Android client. I have been inspired by this video , although I would like to apply these principles to the client side in this case. Let's say that there's a

Repository

which uses a

RemoteApi

and I'd like to create a new user on the backend. The

RemoteApi

does the POST call using Ktor, and returns the result of the

Either<ApiError, UserDTO>

type, where

ApiError

encapsules any network exceptions, internal server errors, etc. Now, I would like to parse expected errors (like

UserAlreadyExists

) as

UserError

of the common

DomainError

sealed type (similar to the video). I'd like the

Repository

to get the`Either<ApiError, UserDTO>` from the

RemoteApi

, process the known errors and return something like the

Either<UserError, UserDTO>

type. The problem with

Either<UserError, UserDTO>

is, that

Hi! I am trying to model the error handling in our Android client. I have been inspired by this video , although I would like to apply these principles to the client side in this case. Let's say that there's a

Repository

which uses a

RemoteApi

and I'd like to create a new user on the backend. The

RemoteApi

does the POST call using Ktor, and returns the result of the

Either<ApiError, UserDTO>

type, where

ApiError

encapsules any network exceptions, internal server errors, etc. Now, I would like to parse expected errors (like

UserAlreadyExists

) as

UserError

of the common

DomainError

sealed type (similar to the video). I'd like the

Repository

to get the`Either<ApiError, UserDTO>` from the

RemoteApi

, process the known errors and return something like the

Either<UserError, UserDTO>

type. The problem with

Either<UserError, UserDTO>

is, that when a network exception occurs, it is an

ApiError

and not a

UserError

. The

Repository

would have to return something like

Either<Either<ApiError,UserError>, UserDTO>

which looks weird, or? So with a hierarchy like this:

sealed interface Error

Hi! I am trying to model the error handling in our Android client. I have been inspired by this video , although I would like to apply these principles to the client side in this case. Considering this hierarchy:

sealed interface Error
sealed interface ApiError : Error {
    object NetworkError : ApiError
    object Unauthorized : ApiError
    object ServerError : ApiError
}
sealed interface DomainError : Error
sealed interface UserError : DomainError {
    object AlreadyExists : UserError
}
sealed interface BookError : DomainError {
    object AlreadyReserved : UserError
}

class RemoteApi {
    fun createUser(): Either<ApiError, UserDTO>
}
class Repository {
    fun createUser(): Either<UserError, UserDTO> (?) {
        val response: Either<ApiError, UserDTO> = remoteApi.createUser()
        // ... map known errors to UserError and return
    }
}

Let's say that there's a

Repository

which uses a

RemoteApi

and I'd like to create a new user on the backend. The

RemoteApi

does the POST call using Ktor, and returns the result of the

Either<ApiError, UserDTO>

type, where

ApiError

encapsules any network exceptions, internal server errors, etc. Now, I would like to parse expected errors (like

UserAlreadyExists

) as

UserError

of the common

DomainError

sealed type (similar to the video). I'd like the

Repository

to get the`Either<ApiError, UserDTO>` from the

RemoteApi

, process the known errors and return something like the

Either<UserError, UserDTO>

type. The problem with

Either<UserError, UserDTO>

is, that when a network exception occurs, it is an

ApiError

and not a

UserError

. The

Repository

would have to return something like

Either<Either<ApiError, UserError>, UserDTO>

which looks weird, or? You could return

Either<Error, UserDTO>

to contain both

ApiError

and

UserError

, but then you would also allow the

Error

to be a

BookError

, which would get ugly in when statements. Maybe using

Either<Error<UserError>, UserDTO>

would be the best, but I'm having trouble modelling the data types like that. Does anyone know of an elegant solutions for this, or this problem of modelling errors in repositories overall? Thank you.

hello! I’ve been out of the loop for a bit but have been using arrow a lot at work which has been great. One think that has come up recently is the possibility of reducing boilerplate / mapping with explicit sealed classes for failures between layers/function calls with a kotlin Union type. I remember there being a POC for a union type a while ago. Is that something that’s close to being a reality? 🤞 So instead of

sealed interface FooFailure {
  object Failure1: FooFailure
  object Failure2: FooFailure
}
fun foo(): Either<FooFailure, Unit> = TODO()

sealed interface BarFailure {
  data class FooFailed(message: String): BarFailure
  object Failure1: BarFailure
  ...
}
fun bar(input: Input): Either<BarFailure, Unit> = either {
  input.validate().bind() // Could be BarFailure.Failure1
  foo().mapLeft { when (it) {
    FooFailure.Failure1 -> BarFailure.FooFailed("Failure 1")
    FooFailure.Failure2 -> BarFailure.FooFailed("Failure 2")
  }}.bind()
}

maybe

sealed interface FooFailure {
  object Failure1: FooFailure
  object Failure2: FooFailure
}
fun foo(): Either<FooFailure, Unit> = TODO()

sealed interface BarFailure {
  object Failure1: BarFailure
  ...
}
fun bar(input: Input): Either<BarFailure|FooFailure, Unit> = either {
  input.validate().bind() // Could be BarFailure.Failure1 or some other bar specific failure
  foo().bind()
}

but still being able to exhaustively when/pattern match on it. Ideally, in a flat way, but even having it be nested is fine.

bar(someInput()).fold(
  ifLeft = { when (it) {
    FooFailure.Failure1 -> TODO()
    FooFailure.Failure2 -> TODO()
    BarFailure.Failure1 -> TODO()
  }}, 
  ifRight = { TODO() }
)

Thanks!

I want to do

String? -> Validated<E, String> -> Validated<E, A>

(in my case converting a String? to UInt). First step is easy with

fromNullable

, but I'm not sure how to map a validated while catching.. I think I'm looking for a

mapCatching(handleError: (Throwable) -> E, f: (A) -> B)

but it doesn't seem to exist? 🙂

I wonder if there should be a variant in the EffectScope besides the existing suspend fun ensure(condition: Boolean, shift: () -> R): Unit, that expects a suspend () -> R function for shift. Would this be possible? If not, what would be an elegant alternative to this?

[Fixed]

ensureNotNull

exists as an extension function on

EffectScope

Hm I tried to use the ensure function

public suspend fun ensure(condition: Boolean, shift: () -> R)

inside the

EffectScope

scope today and I was missing the nice functionality of the kotlin

require

function which by using a contract allows the compiler to auto-infer the type after that function. Specifically when doing a require not null check in my case. Since the ensure function does not do that, is there some other API I’m missing which could help me out, or should I just do

!!

since I know myself at that point that the item is not null?

However, seems legit, but maybe there is an existing tool for such kind of tasks.

Hello world, Recently I was playing around and trying to integrate

arrow-optics

into one of our projects, but stumbled upon an issue. When declaring a

typealias

in the same file where I have

@optics

annotation, build of the gradle application fails with

Duplicated JVM name error

. I was able to overcome the issue by declaring

@file:JvmName("JvmNameOfFile")

, but quite curious to know if there are any other more elegant ways to fix it and fix the root cause. Any help would be much appreciated 🙏

I thought you folks might be interested in my parse don't validate library that is built on Arrow's Validated and NonEmptyList types. https://github.com/sksamuel/tribune

Hello everyone! We are considering renaming the interface

EffectScope

and the operation

shift

to something else. 99% of the time shift is used for error propagation or short-circuiting. We were wondering which one of the following you prefer: 1️⃣ Shift

context(Shift<Error>)
suspend fun example(): Int = shift(Error)

2️⃣ Raise

context(Raise<Error>)
suspend fun example(): Int = raise(Error)

3️⃣ CanFail

context(CanFail<Error>)
suspend fun example(): Int = fail(Error)

For more context on this see https://github.com/arrow-kt/arrow/pull/2797#issuecomment-1222239640 If you are interested in helping us decide please vote with one of those numbers or feel free to propose a new one or any question as thread comments to this post. Thanks!

anyone has experience/examples using Arrow in kmm, especially when interoperating with Swift?

This has probably been asked before, but I couldn’t find it from a quick search. Why doesn’t

shift

return

Nothing

? It’s declared as

suspend fun <B> shift(r: R): B

but it could instead be

suspend fun shift(r: R): Nothing

The reason I ask is specifically because of this use case:

var failure: MyFailure? = null
val effect = eagerEffect<MyFailure, String> {
    failure?.let { shift(it) } // "Not enough information to infer type variable B"
    "some result"
}

The fix is to be explicit about the

Nothing

type, which feels super weird:

val effect = eagerEffect<MyFailure, String> {
    failure?.let { shift<Nothing>(it) }
    "some result"
}

I want to init a class

val

property in the

init

block of a class based on some

Either

value. However, whenever I use any of the

Either

related functions like

fold

or

either.eager

block (which take a lambda as parameter) and I try to set the class property inside the lambda I get the error "Captured member variables initialization is forbidden due to possible reassignment". Is my only option really something like:

myProperty = if (either.isRight()) either.value else defaultValue

?