cps-async-connect-cats-effect
API
Generated with
cps-async-connect-cats-effect/cps.monads.catsEffect

cps.monads.catsEffect

package cps.monads.catsEffect

Members list

Concise view

Type members

Classlikes

class AsyncScopeInferArg[F[_], C <: CpsMonadContext[[A] =>> Resource[F, A]]](using am: Aux[[A] =>> Resource[F, A], C], mc: MonadCancel[F, Throwable])

part of asyncScope

part of asyncScope

Attributes

See also:

asyncScope

Graph
Supertypes
class Object
trait Matchable
class Any
class CatsAsync[F[_]](using x$1: Async[F]) extends CatsMonadThrow[F] with CpsAsyncEffectMonad[F]

Attributes

Graph
Supertypes
trait CpsAsyncEffectMonad[F]
trait CpsEffectMonad[F]
trait CpsAsyncMonad[F]
trait CpsTryMonad[F]
trait CpsThrowMonad[F]
class CatsMonad[F]
trait CpsMonadInstanceContext[F]
trait CpsMonad[F]
trait CpsAwaitable[F]
class Object
trait Matchable
class Any
Known subtypes
class CatsConcurrent[F[_]](using x$1: Concurrent[F], x$2: Async[F]) extends CatsAsync[F] with CpsConcurrentEffectMonad[F]

Attributes

Graph
Supertypes
trait CpsConcurrentEffectMonad[F]
trait CpsConcurrentMonad[F]
class CatsAsync[F]
trait CpsAsyncEffectMonad[F]
trait CpsEffectMonad[F]
trait CpsAsyncMonad[F]
trait CpsTryMonad[F]
trait CpsThrowMonad[F]
class CatsMonad[F]
trait CpsMonadInstanceContext[F]
trait CpsMonad[F]
trait CpsAwaitable[F]
class Object
trait Matchable
class Any
Known subtypes
class CatsIOCpsAsyncMonad extends CatsConcurrent[IO]

CpsAsyncMonad for cats-effect.

CpsAsyncMonad for cats-effect.

Attributes

Graph
Supertypes
class CatsConcurrent[IO]
trait CpsConcurrentEffectMonad[IO]
trait CpsConcurrentMonad[IO]
class CatsAsync[IO]
trait CpsAsyncEffectMonad[IO]
trait CpsEffectMonad[IO]
trait CpsAsyncMonad[IO]
class CatsMonadThrow[IO]
trait CpsTryMonad[IO]
trait CpsThrowMonad[IO]
class CatsMonad[IO]
trait CpsMonadInstanceContext[IO]
trait CpsMonad[IO]
trait CpsAwaitable[IO]
class Object
trait Matchable
class Any
class CatsMonad[F[_]](using mf: Monad[F]) extends CpsMonad[F] with CpsMonadInstanceContext[F]

Attributes

Graph
Supertypes
trait CpsMonadInstanceContext[F]
trait CpsMonad[F]
trait CpsAwaitable[F]
class Object
trait Matchable
class Any
Known subtypes
class CatsAsync[F]
class CatsMonadThrow[F[_]](using x$1: MonadThrow[F]) extends CatsMonad[F] with CpsTryMonad[F]

Attributes

Graph
Supertypes
trait CpsTryMonad[F]
trait CpsThrowMonad[F]
class CatsMonad[F]
trait CpsMonadInstanceContext[F]
trait CpsMonad[F]
trait CpsAwaitable[F]
class Object
trait Matchable
class Any
Known subtypes
class CatsAsync[F]

Value members

Concrete methods

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

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]]

Attributes

See also:

[cps.monads.catsEffect.CpsResourceMonad]

Givens

Givens

given catsAsync[F[_]](using Async[F], NotGiven[Concurrent[F]]): CpsAsyncEffectMonad[F]
given catsConcurrent[F[_]](using Concurrent[F], Async[F]): CpsConcurrentEffectMonad[F]
transparent inline given catsIntValueDiscard[F[_]](using CpsAsyncMonad[F]): ValueDiscard[F[Int]]
given catsMemoization[F[_]](using x$1: Concurrent[F]): catsMemoization[F]
given catsMonad[F[_]](using Monad[F]): CpsMonad[F]
given catsMonadThrow[F[_]](using MonadThrow[F]): CpsTryMonad[F]
given catsResourceMemoization[F[_]](using x$1: Concurrent[[X] =>> Resource[F, X]]): catsResourceMemoization[F]
transparent inline given catsUnitValueDiscard[F[_]](using CpsAsyncMonad[F]): ValueDiscard[F[Unit]]
given ioToFutureConversion(using runtime: IORuntime): ioToFutureConversion
given resourceConversion[F[_]]: CpsMonadConversion[F, [A] =>> Resource[F, A]]

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

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

Attributes

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)(using CpsMonadContext[F]): 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
      }
   }

Attributes

extension (resourceSingleton: Resource.type)
transparent inline def using[F[_], A, B](r: Resource[F, A])(inline f: A => B)(using m: CpsMonad[F], cm: MonadCancel[F, Throwable], mc: CpsMonadContext[F]): 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
      }
   }

Attributes

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], mc: CpsMonadContext[F]): 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
      }
   }

Attributes

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], mc: CpsMonadContext[F]): 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
      }
   }

Attributes

Generated with