Deprecate all public functions, data types and generated code for Arr…

arrow-fx-rx2/build.gradle

@@ -1,6 +1,5 @@
 plugins {
     id "org.jetbrains.kotlin.jvm"
-    id "org.jetbrains.kotlin.kapt"
     id "org.jlleitschuh.gradle.ktlint"
 }
 
@@ -10,8 +9,6 @@ apply from: "$DOC_CREATION"
 dependencies {
     compile project(":arrow-fx")
     compile "io.arrow-kt:arrow-annotations:$VERSION_NAME"
-    kapt "io.arrow-kt:arrow-meta:$VERSION_NAME"
-    kaptTest "io.arrow-kt:arrow-meta:$VERSION_NAME"
     testRuntime "org.junit.vintage:junit-vintage-engine:$JUNIT_VINTAGE_VERSION"
     testCompile "io.kotlintest:kotlintest-runner-junit5:$KOTLIN_TEST_VERSION", excludeArrow
     testCompile project(":arrow-fx-test")

arrow-fx-rx2/src/main/kotlin/arrow/fx/rx2/extensions/flowablek.kt

@@ -31,7 +31,6 @@ import arrow.fx.typeclasses.ProcF
 import arrow.fx.Timer
 import arrow.fx.typeclasses.Concurrent
 import arrow.fx.typeclasses.Fiber
-import arrow.extension
 import arrow.fx.rx2.DeprecateRxJava
 import arrow.typeclasses.Applicative
 import arrow.typeclasses.ApplicativeError
@@ -59,14 +58,12 @@ import io.reactivex.subjects.ReplaySubject
 import io.reactivex.disposables.Disposable as RxDisposable
 import arrow.fx.rx2.handleErrorWith as flowableHandleErrorWith
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKFunctor : Functor<ForFlowableK> {
   override fun <A, B> FlowableKOf<A>.map(f: (A) -> B): FlowableK<B> =
     fix().map(f)
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKApplicative : Applicative<ForFlowableK> {
   override fun <A, B> FlowableKOf<A>.ap(ff: FlowableKOf<(A) -> B>): FlowableK<B> =
@@ -82,7 +79,6 @@ interface FlowableKApplicative : Applicative<ForFlowableK> {
     Eval.now(fix().ap(FlowableK.defer { ff.value() }))
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKMonad : Monad<ForFlowableK>, FlowableKApplicative {
   override fun <A, B> FlowableKOf<A>.ap(ff: FlowableKOf<(A) -> B>): FlowableK<B> =
@@ -101,7 +97,6 @@ interface FlowableKMonad : Monad<ForFlowableK>, FlowableKApplicative {
     Eval.now(fix().ap(FlowableK.defer { ff.value() }))
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKFoldable : Foldable<ForFlowableK> {
   override fun <A, B> FlowableKOf<A>.foldLeft(b: B, f: (B, A) -> B): B =
@@ -111,7 +106,6 @@ interface FlowableKFoldable : Foldable<ForFlowableK> {
     fix().foldRight(lb, f)
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKTraverse : Traverse<ForFlowableK> {
   override fun <A, B> FlowableKOf<A>.map(f: (A) -> B): FlowableK<B> =
@@ -127,7 +121,6 @@ interface FlowableKTraverse : Traverse<ForFlowableK> {
     fix().foldRight(lb, f)
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKApplicativeError :
   ApplicativeError<ForFlowableK, Throwable>,
@@ -139,7 +132,6 @@ interface FlowableKApplicativeError :
     fix().flowableHandleErrorWith { f(it).fix() }
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKMonadError :
   MonadError<ForFlowableK, Throwable>,
@@ -151,18 +143,15 @@ interface FlowableKMonadError :
     fix().flowableHandleErrorWith { f(it).fix() }
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKMonadThrow : MonadThrow<ForFlowableK>, FlowableKMonadError
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKBracket : Bracket<ForFlowableK, Throwable>, FlowableKMonadThrow {
   override fun <A, B> FlowableKOf<A>.bracketCase(release: (A, ExitCase<Throwable>) -> FlowableKOf<Unit>, use: (A) -> FlowableKOf<B>): FlowableK<B> =
     fix().bracketCase({ use(it) }, { a, e -> release(a, e) })
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKMonadDefer : MonadDefer<ForFlowableK>, FlowableKBracket {
   override fun <A> defer(fa: () -> FlowableKOf<A>): FlowableK<A> =
@@ -171,7 +160,6 @@ interface FlowableKMonadDefer : MonadDefer<ForFlowableK>, FlowableKBracket {
   fun BS(): BackpressureStrategy = BackpressureStrategy.BUFFER
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKAsync :
   Async<ForFlowableK>,
@@ -186,7 +174,6 @@ interface FlowableKAsync :
     fix().continueOn(ctx)
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKEffect :
   Effect<ForFlowableK>,
@@ -273,7 +260,6 @@ fun FlowableK.Companion.concurrent(dispatchers: Dispatchers<ForFlowableK> = Flow
   override fun dispatchers(): Dispatchers<ForFlowableK> = dispatchers
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKDispatchers : Dispatchers<ForFlowableK> {
   override fun default(): CoroutineContext =
@@ -283,7 +269,6 @@ interface FlowableKDispatchers : Dispatchers<ForFlowableK> {
     IOScheduler
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKConcurrentEffect : ConcurrentEffect<ForFlowableK>, FlowableKEffect {
   override fun <A> FlowableKOf<A>.runAsyncCancellable(cb: (Either<Throwable, A>) -> FlowableKOf<Unit>): FlowableK<Disposable> =
@@ -389,22 +374,19 @@ fun FlowableK.Companion.effectMissing(): FlowableKEffect = object : FlowableKEff
   override fun BS(): BackpressureStrategy = BackpressureStrategy.MISSING
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKTimer : Timer<ForFlowableK> {
   override fun sleep(duration: Duration): FlowableK<Unit> =
     FlowableK(Flowable.timer(duration.nanoseconds, TimeUnit.NANOSECONDS)
       .map { Unit })
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKFunctorFilter : FunctorFilter<ForFlowableK>, FlowableKFunctor {
   override fun <A, B> Kind<ForFlowableK, A>.filterMap(f: (A) -> Option<B>): FlowableK<B> =
     fix().filterMap(f)
 }
 
-@extension
 @Deprecated(DeprecateRxJava)
 interface FlowableKMonadFilter : MonadFilter<ForFlowableK>, FlowableKMonad {
   override fun <A> empty(): FlowableK<A> =

arrow-fx-rx2/src/main/kotlin/arrow/fx/rx2/extensions/flowablek/applicative/FlowableKApplicative.kt

@@ -0,0 +1,94 @@
+package arrow.fx.rx2.extensions.flowablek.applicative
+
+import arrow.Kind
+import arrow.fx.rx2.DeprecateRxJava
+import arrow.fx.rx2.FlowableK
+import arrow.fx.rx2.FlowableK.Companion
+import arrow.fx.rx2.ForFlowableK
+import arrow.fx.rx2.extensions.FlowableKApplicative
+import arrow.typeclasses.Monoid
+import kotlin.Deprecated
+import kotlin.Function1
+import kotlin.Int
+import kotlin.PublishedApi
+import kotlin.Suppress
+import kotlin.Unit
+import kotlin.collections.List
+import kotlin.jvm.JvmName
+
+/**
+ * cached extension
+ */
+@PublishedApi()
+internal val applicative_singleton: FlowableKApplicative = object :
+    arrow.fx.rx2.extensions.FlowableKApplicative {}
+
+@JvmName("just1")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(DeprecateRxJava)
+fun <A> A.just(): FlowableK<A> = arrow.fx.rx2.FlowableK.applicative().run {
+  this@just.just<A>() as arrow.fx.rx2.FlowableK<A>
+}
+
+@JvmName("unit")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(DeprecateRxJava)
+fun unit(): FlowableK<Unit> = arrow.fx.rx2.FlowableK
+   .applicative()
+   .unit() as arrow.fx.rx2.FlowableK<kotlin.Unit>
+
+@JvmName("map")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(DeprecateRxJava)
+fun <A, B> Kind<ForFlowableK, A>.map(arg1: Function1<A, B>): FlowableK<B> =
+    arrow.fx.rx2.FlowableK.applicative().run {
+  this@map.map<A, B>(arg1) as arrow.fx.rx2.FlowableK<B>
+}
+
+@JvmName("replicate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(DeprecateRxJava)
+fun <A> Kind<ForFlowableK, A>.replicate(arg1: Int): FlowableK<List<A>> =
+    arrow.fx.rx2.FlowableK.applicative().run {
+  this@replicate.replicate<A>(arg1) as arrow.fx.rx2.FlowableK<kotlin.collections.List<A>>
+}
+
+@JvmName("replicate")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(DeprecateRxJava)
+fun <A> Kind<ForFlowableK, A>.replicate(arg1: Int, arg2: Monoid<A>): FlowableK<A> =
+    arrow.fx.rx2.FlowableK.applicative().run {
+  this@replicate.replicate<A>(arg1, arg2) as arrow.fx.rx2.FlowableK<A>
+}
+
+@Suppress(
+  "UNCHECKED_CAST",
+  "NOTHING_TO_INLINE"
+)
+@Deprecated(DeprecateRxJava)
+inline fun Companion.applicative(): FlowableKApplicative = applicative_singleton