Flag new 2.0 APIs as experimental

arrow-libs/core/arrow-core-high-arity/src/commonMain/kotlin/arrow/core/raise/RaiseAccumulate.kt

@@ -1,4 +1,4 @@
-@file:OptIn(ExperimentalTypeInference::class, ExperimentalContracts::class)
+@file:OptIn(ExperimentalTypeInference::class, ExperimentalContracts::class, ExperimentalRaiseAccumulateApi::class)
 @file:JvmMultifileClass
 @file:JvmName("RaiseHighArityKt")
 

arrow-libs/core/arrow-core/api/arrow-core.api

@@ -892,6 +892,9 @@ public final class arrow/core/raise/DefaultRaise : arrow/core/raise/Raise {
 public abstract interface annotation class arrow/core/raise/DelicateRaiseApi : java/lang/annotation/Annotation {
 }
 
+public abstract interface annotation class arrow/core/raise/ExperimentalRaiseAccumulateApi : java/lang/annotation/Annotation {
+}
+
 public abstract interface annotation class arrow/core/raise/ExperimentalTraceApi : java/lang/annotation/Annotation {
 }
 

arrow-libs/core/arrow-core/api/arrow-core.klib.api

@@ -10,6 +10,10 @@ open annotation class arrow.core.raise/DelicateRaiseApi : kotlin/Annotation { //
     constructor <init>() // arrow.core.raise/DelicateRaiseApi.<init>|<init>(){}[0]
 }
 
+open annotation class arrow.core.raise/ExperimentalRaiseAccumulateApi : kotlin/Annotation { // arrow.core.raise/ExperimentalRaiseAccumulateApi|null[0]
+    constructor <init>() // arrow.core.raise/ExperimentalRaiseAccumulateApi.<init>|<init>(){}[0]
+}
+
 open annotation class arrow.core.raise/ExperimentalTraceApi : kotlin/Annotation { // arrow.core.raise/ExperimentalTraceApi|null[0]
     constructor <init>() // arrow.core.raise/ExperimentalTraceApi.<init>|<init>(){}[0]
 }

arrow-libs/core/arrow-core/src/commonMain/kotlin/arrow/core/raise/RaiseAccumulate.kt

@@ -460,7 +460,7 @@ public inline fun <Error, A, B, C, D, E, F, G, H, I> Raise<NonEmptyList<Error>>.
  * [error accumulation](https://arrow-kt.io/learn/typed-errors/working-with-typed-errors/#accumulating-errors)
  * and how to use it in [validation](https://arrow-kt.io/learn/typed-errors/validation/).
  */
-@RaiseDSL
+@RaiseDSL @OptIn(ExperimentalRaiseAccumulateApi::class)
 public inline fun <Error, A, B, C, D, E, F, G, H, I, J> Raise<NonEmptyList<Error>>.zipOrAccumulate(
   @BuilderInference action1: RaiseAccumulate<Error>.() -> A,
   @BuilderInference action2: RaiseAccumulate<Error>.() -> B,
@@ -540,7 +540,7 @@ public inline fun <Error, A> Raise<NonEmptyList<Error>>.forEachAccumulating(
  * Allows to change what to do once the first error is raised.
  * Used to provide more performant [mapOrAccumulate].
  */
-@PublishedApi @JvmSynthetic
+@PublishedApi @JvmSynthetic @OptIn(ExperimentalRaiseAccumulateApi::class)
 internal inline fun <Error, A> Raise<NonEmptyList<Error>>.forEachAccumulatingImpl(
   iterator: Iterator<A>,
   @BuilderInference block: RaiseAccumulate<Error>.(item: A, hasErrors: Boolean) -> Unit
@@ -671,6 +671,12 @@ public inline fun <K, Error, A, B> Raise<NonEmptyList<Error>>.mapOrAccumulate(
   }
 }
 
+@RequiresOptIn(level = RequiresOptIn.Level.WARNING, message = "This API is work-in-progress and is subject to change.")
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.FUNCTION)
+public annotation class ExperimentalRaiseAccumulateApi
+
+@ExperimentalRaiseAccumulateApi
 public inline fun <Error, A> Raise<NonEmptyList<Error>>.accumulate(
   block: RaiseAccumulate<Error>.() -> A
 ): A {
@@ -681,6 +687,7 @@ public inline fun <Error, A> Raise<NonEmptyList<Error>>.accumulate(
   return result
 }
 
+@ExperimentalRaiseAccumulateApi
 public inline fun <Error, A, R> accumulate(
   raise: (Raise<NonEmptyList<Error>>.() -> A) -> R,
   crossinline block: RaiseAccumulate<Error>.() -> A
@@ -771,24 +778,30 @@ public open class RaiseAccumulate<Error>(
   @PublishedApi internal fun hasErrors(): Boolean = errors.isNotEmpty()
   @PublishedApi internal fun raiseErrors(): Nothing = raise.raise(errors.toNonEmptyListOrNull()!!)
 
+  @ExperimentalRaiseAccumulateApi
   public fun <A> Either<Error, A>.bindOrAccumulate(): Value<A> =
     accumulating { this@bindOrAccumulate.bind() }
 
+  @ExperimentalRaiseAccumulateApi
   public fun <A> Iterable<Either<Error, A>>.bindAllOrAccumulate(): Value<List<A>> =
     accumulating { this@bindAllOrAccumulate.bindAll() }
 
+  @ExperimentalRaiseAccumulateApi
   public fun <A> EitherNel<Error, A>.bindNelOrAccumulate(): Value<A> =
     accumulating { this@bindNelOrAccumulate.bindNel() }
 
+  @ExperimentalRaiseAccumulateApi
   public fun ensureOrAccumulate(condition: Boolean, raise: () -> Error) {
     accumulating { ensure(condition, raise) }
   }
 
+  @ExperimentalRaiseAccumulateApi
   public fun <B: Any> ensureNotNullOrAccumulate(value: B?, raise: () -> Error) {
     contract { returns() implies (value != null) }
     ensureOrAccumulate(value != null, raise)
   }
 
+  @ExperimentalRaiseAccumulateApi
   public inline fun <A> accumulating(block: RaiseAccumulate<Error>.() -> A): Value<A> =
     recover(inner@{
       Ok(block(RaiseAccumulate(this@inner)))

arrow-libs/core/arrow-core/src/commonTest/kotlin/arrow/core/raise/RaiseAccumulateSpec.kt

@@ -1,3 +1,4 @@
+@file:OptIn(ExperimentalRaiseAccumulateApi::class)
 package arrow.core.raise
 
 import arrow.core.NonEmptyList

arrow-libs/fx/arrow-fx-coroutines/api/arrow-fx-coroutines.api

@@ -279,3 +279,6 @@ public final class arrow/fx/coroutines/await/AwaitAllScopeKt {
 	public static final fun awaitAll (Lkotlinx/coroutines/CoroutineScope;Lkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 }
 
+public abstract interface annotation class arrow/fx/coroutines/await/ExperimentalAwaitAllApi : java/lang/annotation/Annotation {
+}
+

arrow-libs/fx/arrow-fx-coroutines/api/arrow-fx-coroutines.klib.api

@@ -6,6 +6,10 @@
 // - Show declarations: true
 
 // Library unique name: <io.arrow-kt:arrow-fx-coroutines>
+open annotation class arrow.fx.coroutines.await/ExperimentalAwaitAllApi : kotlin/Annotation { // arrow.fx.coroutines.await/ExperimentalAwaitAllApi|null[0]
+    constructor <init>() // arrow.fx.coroutines.await/ExperimentalAwaitAllApi.<init>|<init>(){}[0]
+}
+
 open annotation class arrow.fx.coroutines/ResourceDSL : kotlin/Annotation { // arrow.fx.coroutines/ResourceDSL|null[0]
     constructor <init>() // arrow.fx.coroutines/ResourceDSL.<init>|<init>(){}[0]
 }

arrow-libs/fx/arrow-fx-coroutines/src/commonMain/kotlin/arrow/fx/coroutines/await/AwaitAllScope.kt

@@ -6,15 +6,23 @@ import kotlinx.coroutines.async as coroutinesAsync
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.InternalForInheritanceCoroutinesApi
 import kotlinx.coroutines.awaitAll as coroutinesAwaitAll
 import kotlinx.coroutines.coroutineScope
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
+@RequiresOptIn(level = RequiresOptIn.Level.WARNING, message = "This API is work-in-progress and is subject to change.")
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.FUNCTION)
+public annotation class ExperimentalAwaitAllApi
+
+@ExperimentalAwaitAllApi
 public suspend fun <A> awaitAll(
   block: suspend AwaitAllScope.() -> A
 ): A = coroutineScope { block(AwaitAllScope(this)) }
 
+@ExperimentalAwaitAllApi
 public suspend fun <A> CoroutineScope.awaitAll(
   block: suspend AwaitAllScope.() -> A
 ): A = block(AwaitAllScope(this))
@@ -61,6 +69,7 @@ public class AwaitAllScope(
     return Await(deferred)
   }
 
+  @OptIn(InternalForInheritanceCoroutinesApi::class)
   private inner class Await<T>(
     private val deferred: Deferred<T>
   ): Deferred<T> by deferred {