I do have this:

class MainSyncRepository<F, K, Q : Get<K>, A>(
    private val mainDataSource: DataSource<F, Q, A>,
    private val storeDataSource: StoreDataSource<F, K, A>,
    private val fallbackChecks: List<F> = emptyList()
) : Repository<F, Q, A> {

    
    override suspend fun invoke(q: Q): Either<F, A> =
        mainDataSource(q)
            .flatMap { storeDataSource(Put(q.key, Some(it))) }
            .handleErrorWith { f ->
                if (f in fallbackChecks) {
                    storeDataSource(q)
                        .mapLeft { f }
                } else {
                    Either.Left(f)
                }
            }
}

and I’d like to translate it with context receivers (this is like i would wrap the whole invoke function in a

either

dsl for instance. How would i manage to translate the

handleErrorWith

? cc @simon.vergauwen

you should be able to use

recover

for this

could you elavorate a bit, please? 🙏🏻

I don't know exactly what's happening there, but here's a go:

override suspend fun invoke(q: Q): Either<F, A> = either {
  recover({
    val source = mainDataSource(q).bind()
    storeDataSource(Put(q.key, Some(source))).bind()
  }) { f ->
    if (f in fallbackChecks) withError({ f }) { storeDataSource(q).bind() }
    else raise(f)
  }
}

ooook, that makes sense.

it didn't lose

bind

everywhere, only in those places in which you were to provide a value for the error

how should i replace it then?

q.value.bind { DataNotFound }

mmm, I'll have to check...

I used fold lately…

q.value.bind { DataNotFound }

This can be

q.value.getOrElse { raise(DataNotFound) }

.