'accumulate' for Raise

[serras]

This PR proposed a one-for-all accumulating map for Raise. The signature is not the greatest at this moment, because Raise needs to appear in receiver position, so the list goes as first argument.

public fun <R, A, B> Raise<NonEmptyList<R>>.accumulate(
  list: Iterable<A>,
  block: Raise<R>.(A) -> B
): List<B>

Interestingly, this function is actually generic over the way we run the Raise.

[raulraja]

Thanks @serras, looks great !

[nomisRev]

That signature makes me sad 😞 I'm personally not really in favour of adding this method until we have context receivers. I think the pattern of working over Raise<E> will not really catch on they become stable.

You can of course call bind here inside of block, but then this seems like a micro-optimisation compared to the current signature.

Working E doesn't solve any problems, since you typically want Nel<E>. The signature below suffers from a second problem which is that it's not inline, which is not possible inside interfaces. So it doesn't allow foreign suspend to pass through, which is a must in this model of "transformers". To solve this it would also need to be put outside of the interface which makes this suffer from the same issue.

interface Raise<E> {
  fun <A, B> Iterable<A>.mapOrAccumulate(combine: (E,E) -> E, transform: Raise<E>.(A) -> B): List<B>
}

[github-actions]

Kover Report

File	Coverage [81.40%]
arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/continuations/Raise.kt	81.40%

Total Project Coverage	42.12%

[serras]

@nomisRev I agree that context receivers will make this much nicer. However, I don't think that the following looks so terrible,

accumulate(elements) {
  checkValidity(it)
}

when compared to

elements.accumulate {
  checkValidity(it)
}

[nomisRev]

Alright, that's fair. Before approving, I am wondering accumulate is the best name for this operator? It still has the shape of map, like we're using mapOrAccumulate for the extension functions for Either, should we use the same name here?

I think we should add the other signature inside Raise already since that fits.

interface Raise<in E> {
  fun <A, B> Iterable<A>.mapOrAccumulate(
    semigroup: Semigroup<E>,
    transform: Raise<E>.(A) -> B
  ): List<B>
}

[serras]

@nomisRev I updated the code to use the more general version you mention; in fact I've added an even more general one because to implement the version with NonEmptyList<E> you may want a way to "embed" a single E into the non-empty list.

[i-walker]

Is it possible to instead use a combination of mapLeft and mapAccumulate without the embed parameter. This way the method isnt too convoluted @serras? Unless that is what we were going for

[serras]

@i-walker indeed, I think you're right. I've pushed a new commit in which mapOrAccumulate within Raise is simpler, and I use a combination with mapLeft to implement the NonEmptyList version