Glossary

Search and filter commands for Cats Effect → ZIO

All 66 commands

Cats Effect

ZIO

ZIO.succeed(a)

IO.pure(a)(Lift pure value into effect)

ZIO.fail(e)

IO.raiseError(e)(Lift error into effect)

ZIO.effect(thunk)

IO.delay(thunk)(Suspend side effect)

ZIO.attempt(thunk)

IO.blocking(thunk)(May throw, blocking)

UIO[A]

IO[A](No error type (Nothing))

ZIO.fromEither(e)

IO.fromEither(e)(From Either)

ZIO.fromOption(o)

IO.fromOption(o)(From Option)

effect.catchAll(f)

effect.handleErrorWith(f)(Recover from error)

effect.orElse(fallback)

effect.handleErrorWith(_ => fallback)(Fallback on error)

effect.mapError(f)

effect.adaptError(f)(Transform error)

effect.retry(schedule)

effect.timeout + handleError(Manual retries in CE)

ZIO.collectAll(list)

list.sequence(Sequence effects)

ZLayer.succeed(service)

Resource.pure(service)(Create dependency)

effect.provideLayer(layer)

Kleisli.run(effect)(service)(Inject dependency)

ZIO.service[A]

IO.ask[A](Get from env (Kleisli))

layer1 ++ layer2

Resource.forProductN(Compose dependencies)

ZManaged.acquireRelease

Resource.make(Resource lifecycle)

effect.fork

effect.start(Spawn fiber)

fiber.join

fiber.join(Await fiber result)

effect1.race(effect2)

effect1.race(effect2)(First to finish wins)

effect.timeout(duration)

effect.timeout(duration)(Cancel if too slow)

fiber.interrupt

fiber.cancel(Cancel fiber)

ZIO.supervised

Resource with cancel(Manual supervision)

ZIO.collectAllPar(list)

list.parSequence(Parallel execution)

ZStream(values)

Stream(values)(Create stream)

stream.map(f)

stream.map(f)(Transform elements)

stream.filter(p)

stream.filter(p)(Filter elements)

stream.runCollect

stream.compile.toList(Collect to list)

stream.mapZIO(f)

stream.evalMap(f)(Effectful map)

stream.merge(other)

stream.merge(other)(Merge streams)

ZStream.fromPath(path)

Files[IO].readAll(path)(File streaming (fs2))

TRef.make(a)

TRef.of[F](a)(Create transactional reference)

STM.succeed(a)

STM.pure(a)(Pure STM value)

STM.retry

STM.retry(Retry transaction on TRef change)

transaction.commit

transaction.commit[F](Commit STM to effect)

TMap.empty[K, V]

TMap.empty[F, K, V](Transactional hash map)

TQueue.unbounded[A]

TQueue.unbounded[F, A](Transactional queue)

ZIO.config[A]

ConfigValue[F, A].load[F](Load configuration)

Config.string

env(key).as[String](String configuration)

Config.int

env(key).as[Int](Integer configuration)

ConfigProvider.envProvider

env(key) default(Environment variable source)

deriveConfig[A]

parMapN(A)(Automatic config derivation)

cfg.withDefault(value)

ConfigValue.default(value)(Default value for config)

cfg.validate(msg)(p)

Custom ConfigDecoder(Configuration validation)

Http.collect[Request] { case ... }

HttpRoutes.of[IO] { case ... }(Define HTTP routes)

Response.text(body)

Ok(body)(Text response)

Client.request(url)

client.expect[String](uri)(HTTP GET request)

Server.serve(app)

BlazeServerBuilder[IO].serve(Start HTTP server)

Method.GET -> Root / "path"

GET -> Root / "path"(GET route pattern)

req.body.asJson[A]

req.as[A](Parse JSON body)

Response(status, body = Body.fromStream)

Ok(stream)(Streaming response)

query(sql).as[A]

sql"...".query[A](Execute SELECT query)

execute(sql).param(v)

sql"...$v"(Parameterized query)

query(...).transaction

sql"...".transact(xa)(Execute transaction)

ZConnectionPool.h2(url, user, pass)

Transactor.fromDataSource(Connection pool)

execute(sql).returning

.update.withUniqueGeneratedKeys(Insert and return ID)

sql ++ where

Fragment ++ Fragment(Query composition)

object Main extends ZIOAppDefault

object Main extends IOApp.Simple(Application entry)

override val run: ZIO[...]

val run: IO[Throwable, Unit](Main effect)

override val bootstrap

IORuntime (implicit)(Runtime config)

effect.onInterrupt(f)

effect.onCancel(f)(Shutdown hook)

ZIO.logInfo(msg)

logger.info(msg) (log4cats)(Logging)

zio.toIO

Use in CE via interop(zio-interop-cats)

zio.toResource

Use in CE via interop(Convert ZManaged)

effects.parTupled

effects.parTupled(Via Cats Parallel)

list.traverse(ZIO)

list.traverse(IO)(Cats syntax)