Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
izumi.functional.bio.impl.AsyncMonix.scala Maven / Gradle / Ivy
//package izumi.functional.bio.impl
//
//import java.util.concurrent.CompletionStage
//
//import izumi.functional.bio.Exit.MonixExit._
//import izumi.functional.bio.{Async2, Exit, Fiber2}
//import monix.bio.{Cause, IO, Task}
//
//import scala.concurrent.{ExecutionContext, Future}
//import scala.util.Try
//
//object AsyncMonix extends AsyncMonix
//
//class AsyncMonix extends Async2[IO] {
// @inline override final def InnerF: this.type = this
//
// override final def unit: IO[Nothing, Unit] = IO.unit
// override final def pure[A](a: A): IO[Nothing, A] = IO.pure(a)
// override final def sync[A](effect: => A): IO[Nothing, A] = IO.evalTotal(effect)
// override final def syncThrowable[A](effect: => A): IO[Throwable, A] = IO.eval(effect)
// override final def suspend[R, A](effect: => IO[Throwable, A]): IO[Throwable, A] = IO.suspend(effect)
//
// override final def fail[E](v: => E): IO[E, Nothing] = IO.raiseError(v)
// override final def terminate(v: => Throwable): IO[Nothing, Nothing] = IO.terminate(v)
//
// override final def fromEither[E, V](effect: => Either[E, V]): IO[E, V] = IO.suspendTotal(IO.fromEither(effect))
// override final def fromOption[E, A](errorOnNone: => E)(effect: => Option[A]): IO[E, A] = IO.suspendTotal(IO.fromEither(effect.toRight(errorOnNone)))
// override final def fromTry[A](effect: => Try[A]): IO[Throwable, A] = IO.suspendTotal(IO.fromTry(effect))
//
// override final def void[R, E, A](r: IO[E, A]): IO[E, Unit] = r.void
// override final def map[R, E, A, B](r: IO[E, A])(f: A => B): IO[E, B] = r.map(f)
// override final def as[R, E, A, B](r: IO[E, A])(v: => B): IO[E, B] = r.map(_ => v)
//
// override final def tapError[R, E, A, E1 >: E](r: IO[E, A])(f: E => IO[E1, Unit]): IO[E1, A] = r.tapError(f)
// override final def leftMap[R, E, A, E2](r: IO[E, A])(f: E => E2): IO[E2, A] = r.mapError(f)
// override final def leftFlatMap[R, E, A, E2](r: IO[E, A])(f: E => IO[Nothing, E2]): IO[E2, A] = r.flipWith(_ flatMap f)
// override final def flip[R, E, A](r: IO[E, A]): IO[A, E] = r.flip
// override final def bimap[R, E, A, E2, B](r: IO[E, A])(f: E => E2, g: A => B): IO[E2, B] = r.bimap(f, g)
//
// @inline override final def retryWhile[R, E, A](r: IO[E, A])(f: E => Boolean): IO[E, A] = r.onErrorRestartIf(f)
// @inline override final def retryUntil[R, E, A](r: IO[E, A])(f: E => Boolean): IO[E, A] = r.onErrorRestartIf(!f(_))
//
// @inline override final def retryWhileF[R, R1 <: R, E, A](r: IO[E, A])(f: E => IO[Nothing, Boolean]): IO[E, A] = {
// r.onErrorHandleWith {
// e =>
// f(e).flatMap {
// if (_) retryUntilF(r)(f)
// else IO.raiseError(e)
// }
// }
// }
// @inline override final def retryUntilF[R, R1 <: R, E, A](r: IO[E, A])(f: E => IO[Nothing, Boolean]): IO[E, A] = {
// r.onErrorHandleWith {
// e =>
// f(e).flatMap {
// p =>
// if (!p) retryUntilF(r)(f)
// else IO.raiseError(e)
// }
// }
// }
// override final def flatMap[R, E, A, B](r: IO[E, A])(f: A => IO[E, B]): IO[E, B] = r.flatMap(f)
// override final def tap[R, E, A](r: IO[E, A], f: A => IO[E, Unit]): IO[E, A] = r.flatMap(a => f(a).map(_ => a))
//
// override final def tapBoth[R, E, A, E1 >: E](r: IO[E, A])(err: E => IO[E1, Unit], succ: A => IO[E1, Unit]): IO[E1, A] =
// r.tapError(err).flatMap(a => succ(a).map(_ => a))
//
// override final def flatten[R, E, A](r: IO[E, IO[E, A]]): IO[E, A] = r.flatten
// override final def *>[R, E, A, B](r: IO[E, A], next: => IO[E, B]): IO[E, B] = r.flatMap(_ => next)
// override final def <*[R, E, A, B](r: IO[E, A], next: => IO[E, B]): IO[E, A] = r.flatMap(a => next.map(_ => a))
// override final def map2[R, E, A, B, C](r1: IO[E, A], r2: => IO[E, B])(f: (A, B) => C): IO[E, C] = IO.map2(r1, r2)(f)
//
// override final def leftMap2[R, E, A, E2, E3](firstOp: IO[E, A], secondOp: => IO[E2, A])(f: (E, E2) => E3): IO[E3, A] =
// firstOp.onErrorHandleWith(e => secondOp.mapError(f(e, _)))
// override final def orElse[R, E, A, E2](r: IO[E, A], f: => IO[E2, A]): IO[E2, A] = r.onErrorHandleWith(_ => f)
//
// override final def redeem[R, E, A, E2, B](r: IO[E, A])(err: E => IO[E2, B], succ: A => IO[E2, B]): IO[E2, B] = r.redeemWith(err, succ)
// override final def catchAll[R, E, A, E2](r: IO[E, A])(f: E => IO[E2, A]): IO[E2, A] = r.onErrorHandleWith(f)
// override final def catchSome[R, E, A, E1 >: E](r: IO[E, A])(f: PartialFunction[E, IO[E1, A]]): IO[E1, A] = r.onErrorRecoverWith(f)
//
// override final def guarantee[R, E, A](f: IO[E, A], cleanup: IO[Nothing, Unit]): IO[E, A] = f.guarantee(cleanup)
// override final def attempt[R, E, A](r: IO[E, A]): IO[Nothing, Either[E, A]] = r.attempt
// override final def redeemPure[R, E, A, B](r: IO[E, A])(err: E => B, succ: A => B): IO[Nothing, B] = r.redeem(err, succ)
//
// override final def bracket[R, E, A, B](acquire: IO[E, A])(release: A => IO[Nothing, Unit])(use: A => IO[E, B]): IO[E, B] = {
// acquire.bracket(use = use)(release = release)
// }
// override final def bracketCase[R, E, A, B](acquire: IO[E, A])(release: (A, Exit[E, B]) => IO[Nothing, Unit])(use: A => IO[E, B]): IO[E, B] = {
// acquire.bracketE(use = use)(release = (a, exit) => release(a, toExit(exit)))
// }
// override final def guaranteeCase[R, E, A](f: IO[E, A], cleanup: Exit[E, A] => IO[Nothing, Unit]): IO[E, A] = {
// IO.unit.bracketE(use = _ => f)(release = (_, exit) => cleanup(toExit(exit)))
// }
//
// override final def traverse[R, E, A, B](l: Iterable[A])(f: A => IO[E, B]): IO[E, List[B]] = IO.traverse(l)(f)
// override final def sequence[R, E, A, B](l: Iterable[IO[E, A]]): IO[E, List[A]] = IO.sequence(l)
// override final def traverse_[R, E, A](l: Iterable[A])(f: A => IO[E, Unit]): IO[E, Unit] = IO.traverse(l)(f).void
// override final def sequence_[R, E](l: Iterable[IO[E, Unit]]): IO[E, Unit] = IO.sequence(l).void
//
// override final def sandbox[R, E, A](r: IO[E, A]): IO[Exit.Failure[E], A] = {
// r.redeemCauseWith(cause => IO.raiseError(toExit(cause)), a => IO.pure(a))
// }
// override final def yieldNow: IO[Nothing, Unit] = IO.shift
// override final def never: IO[Nothing, Nothing] = IO.never
//
// override final def race[R, E, A](r1: IO[E, A], r2: IO[E, A]): IO[E, A] = IO.race(r1, r2).map(_.merge)
//
// override final def racePair[R, E, A, B](fa: IO[E, A], fb: IO[E, B]): IO[E, Either[(A, Fiber2[IO, E, B]), (Fiber2[IO, E, A], B)]] = {
// IO.racePair(fa, fb).map {
// case Left((a, fiberB)) => Left((a, Fiber2.fromMonix(fiberB)))
// case Right((fiberA, b)) => Right((Fiber2.fromMonix(fiberA), b))
// }
// }
//
// override final def async[E, A](register: (Either[E, A] => Unit) => Unit): IO[E, A] = {
// IO.async(cb => register(_.fold(cb.onError, cb.onSuccess)))
// }
// override final def asyncF[R, E, A](register: (Either[E, A] => Unit) => IO[E, Unit]): IO[E, A] = {
// IO.asyncF(cb => register(_.fold(cb.onError, cb.onSuccess)))
// }
// override final def asyncCancelable[E, A](register: (Either[E, A] => Unit) => Canceler): IO[E, A] = {
// IO.cancelable[E, A](cb => register(_.fold(cb.onError, cb.onSuccess)))
// }
// override final def fromFuture[A](mkFuture: ExecutionContext => Future[A]): IO[Throwable, A] = {
// IO.deferFutureAction(mkFuture)
// }
// // this approach I shamelessly ported from javaz
// override final def fromFutureJava[A](javaFuture: => CompletionStage[A]): IO[Throwable, A] = {
// lazy val cs: CompletionStage[A] = javaFuture
// IO.deferTotal {
// val cf = cs.toCompletableFuture
// if (cf.isDone) {
// Try(cf.get()) match {
// case util.Failure(exception) => Task.terminate(exception)
// case util.Success(value) => Task.pure(value)
// }
// } else {
// IO.async {
// cb =>
// cs.handle[Unit] {
// (v: A, t: Throwable) =>
// val io = Option(t).fold[Either[Cause[Throwable], A]](Right(v))(_ => Left(Cause.Error(t)))
// cb(io)
// }; ()
// }
// }
// }
// }
// override final def uninterruptible[R, E, A](r: IO[E, A]): IO[E, A] = r.uncancelable
//
// override final def parTraverseN[R, E, A, B](maxConcurrent: Int)(l: Iterable[A])(f: A => IO[E, B]): IO[E, List[B]] = IO.parTraverseN(maxConcurrent)(l)(f)
// override final def parTraverseN_[R, E, A, B](maxConcurrent: Int)(l: Iterable[A])(f: A => IO[E, B]): IO[E, Unit] = IO.parTraverseN(maxConcurrent)(l)(f).void
// override final def parTraverse[R, E, A, B](l: Iterable[A])(f: A => IO[E, B]): IO[E, List[B]] = IO.parTraverse(l)(f)
// override final def parTraverse_[R, E, A, B](l: Iterable[A])(f: A => IO[E, B]): IO[E, Unit] = IO.parTraverse(l)(f).void
//
// override final def zipWithPar[R, E, A, B, C](fa: IO[E, A], fb: IO[E, B])(f: (A, B) => C): IO[E, C] = IO.mapBoth(fa, fb)(f)
// override final def zipPar[R, E, A, B](fa: IO[E, A], fb: IO[E, B]): IO[E, (A, B)] = IO.parZip2(fa, fb)
// override final def zipParLeft[R, E, A, B](fa: IO[E, A], fb: IO[E, B]): IO[E, A] = IO.parMap2(fa, fb)((a, _) => a)
// override final def zipParRight[R, E, A, B](fa: IO[E, A], fb: IO[E, B]): IO[E, B] = IO.parMap2(fa, fb)((_, b) => b)
//}
