cps.monads.catsEffect

Type members

Classlikes

class AsyncScopeInferArg[F[_]](using x$1: CpsTryMonad[[A] =>> Resource[F, A]], x$2: MonadCancel[F, Throwable])

part of asyncScope

part of asyncScope

See also

asyncScope

class CatsAsync[F[_]](using x$1: Async[F]) extends CatsMonadThrow[F] with CpsAsyncEffectMonad[F]
class CatsConcurrent[F[_]](using x$1: Concurrent[F], x$2: Async[F]) extends CatsAsync[F] with CpsConcurrentEffectMonad[F]

CpsAsyncMonad for cats-effect.

CpsAsyncMonad for cats-effect.

class CatsMonad[F[_]](using x$1: Monad[F]) extends CpsMonad[F]
class CatsMonadThrow[F[_]](using x$1: MonadThrow[F]) extends CatsMonad[F] with CpsTryMonad[F]

Value members

Concrete methods

def asyncScope[F[_]](using CpsTryMonad[[A] =>> Resource[F, A]], MonadCancel[F, Throwable]): AsyncScopeInferArg[F]

Produce effect with resource-aware scope block.

Produce effect with resource-aware scope block.

val effect = asyncScope[IO] {
   val reader = await(openFile(input))
   val writer = await(openFile(output))
   writer.transformFrom(0,Long.MaxValue,reader)
}

Here evaluation of effect will open reader and wrier, transfer data and then close reader and writer. block inside asyncScope evaluated in CpsResourceMonad[[X]=>>Resource[F,X]]

See also

[cps.monads.catsEffect.CpsResourceMonad]

Concrete fields

final lazy

Givens

Givens

given catsAsync: CpsAsyncMonad[F]
given catsConcurrent: CpsConcurrentMonad[F]
given catsMemoization[F[_]](using val x$1: Concurrent[F]): Pure[F]
given catsMonad: CpsAwaitable[F]
given catsMonadThrow: CpsMonad[F]
given catsResourceMemoization[F[_]](using val x$1: Concurrent[[X] =>> Resource[F, X]]): Pure[[X] =>> Resource[F, X]]
given ioToFutureConversion(using val runtime: IORuntime): CpsMonadConversion[IO, Future]

into F[T] to [A] =>> Resource[F,A] for using inside asyncScope

into F[T] to [A] =>> Resource[F,A] for using inside asyncScope

Extensions

Extensions

extension [F[_], A](r: Resource[F, A])(using m: CpsMonad[F], cm: MonadCancel[F, Throwable])
transparent inline
def useOn[B](inline f: A => B): B

Pseudo-synchronious syntax for resource, which can be used in async block.

Pseudo-synchronious syntax for resource, which can be used in async block.

Usage: assuming we have:

   def open(file: File): Resource[IO, BufferedReader]

we can

   async[IO] {
      ....
      open(file).useOn{ buffer =>
          await(doSomething)
          buffer.write(r)
          result
      }
   }
extension (resourceSingleton: Resource)
transparent inline
def using[F[_], A, B](r: Resource[F, A])(inline f: A => B)(using m: CpsMonad[F], cm: MonadCancel[F, Throwable]): B

Pseudo-synchronious syntax for resource, which can be used in async block.

Pseudo-synchronious syntax for resource, which can be used in async block.

   async[IO] {
      ....
      useing(openFile){ buffer =>
          await(doSomething)
          buffer.write(r)
          result
      }
   }
transparent inline
def using[F[_], A1, A2, B](r1: Resource[F, A1], r2: Resource[F, A2])(inline f: (A1, A2) => B)(using m: CpsMonad[F], cm: MonadCancel[F, Throwable]): B

Pseudo-synchronious syntax for resource, which can be used in async block.

Pseudo-synchronious syntax for resource, which can be used in async block.

   async[IO] {
      ....
      useing(openFile){ buffer =>
          await(doSomething)
          buffer.write(r)
          result
      }
   }
transparent inline
def using[F[_], A1, A2, A3, B](r1: Resource[F, A1], r2: Resource[F, A2], r3: Resource[F, A3])(inline f: (A1, A2, A3) => B)(using m: CpsMonad[F], cm: MonadCancel[F, Throwable]): B

Pseudo-synchronious syntax for resource, which can be used in async block.

Pseudo-synchronious syntax for resource, which can be used in async block.

   async[IO] {
      ....
      useing(openFile){ buffer =>
          await(doSomething)
          buffer.write(r)
          result
      }
   }