zio
Evidence type A is not equal to type B.
Evidence type A is not equal to type B.
Based on https://github.com/milessabin/shapeless.
The entry point for a purely-functional application on the JVM.
The entry point for a purely-functional application on the JVM.
import zio.App import zio.console._ object MyApp extends App { final def run(args: List[String]) = myAppLogic.exitCode def myAppLogic = for { _ <- putStrLn("Hello! What is your name?") n <- getStrLn _ <- putStrLn("Hello, " + n + ", good to meet you!") } yield () }
A value of type CanFail[E] provides implicit evidence that an effect with
error type E can fail, that is, that E is not equal to Nothing.
A value of type CanFail[E] provides implicit evidence that an effect with
error type E can fail, that is, that E is not equal to Nothing.
A Chunk[A] represents a chunk of values of type A.
A Chunk[A] represents a chunk of values of type A. Chunks are designed
are usually backed by arrays, but expose a purely functional, safe interface
to the underlying elements, and they become lazy on operations that would be
costly with arrays, such as repeated concatenation.
The implementation of balanced concatenation is based on the one for Conc-Trees in "Conc-Trees for Functional and Parallel Programming" by Aleksandar Prokopec and Martin Odersky. http://aleksandar-prokopec.com/resources/docs/lcpc-conc-trees.pdf
NOTE: For performance reasons Chunk does not box primitive types. As a
result, it is not safe to construct chunks from heterogeneous primitive
types.
A ChunkBuilder[A] can build a Chunk[A] given elements of type A.
A ChunkBuilder[A] can build a Chunk[A] given elements of type A.
ChunkBuilder is a mutable data structure that is implemented to
efficiently build chunks of unboxed primitives and for compatibility with
the Scala collection library.
ChunkCanBuildFrom provides implicit evidence that a collection of type
Chunk[A] can be built from elements of type A.
ChunkCanBuildFrom provides implicit evidence that a collection of type
Chunk[A] can be built from elements of type A. Since a Chunk[A] can
be built from elements of type A for any type A, this implicit
evidence always exists. It is used primarily to provide proof that the
target type of a collection operation is a Chunk to support high
performance implementations of transformation operations for chunks.
A queue that can only be dequeued.
Describes a strategy for evaluating multiple effects, potentially in parallel.
Describes a strategy for evaluating multiple effects, potentially in
parallel. There are three possible execution strategies: Sequential,
Parallel, and ParallelN.
An Exit[E, A] describes the result of executing an IO value.
An Exit[E, A] describes the result of executing an IO value. The
result is either succeeded with a value A, or failed with a Cause[E].
A fiber is a lightweight thread of execution that never consumes more than a whole thread (but may consume much less, depending on contention and asynchronicity).
A fiber is a lightweight thread of execution that never consumes more than a whole thread (but may consume much less, depending on contention and asynchronicity). Fibers are spawned by forking ZIO effects, which run concurrently with the parent effect.
Fibers can be joined, yielding their result to other fibers, or interrupted, which terminates the fiber, safely releasing all resources.
def parallel[A, B](io1: Task[A], io2: Task[B]): Task[(A, B)] = for { fiber1 <- io1.fork fiber2 <- io2.fork a <- fiber1.join b <- fiber2.join } yield (a, b)
Represents a failure in a fiber.
Represents a failure in a fiber. This could be caused by some non- recoverable error, such as a defect or system error, by some typed error, or by interruption (or combinations of all of the above).
This class is used to wrap ZIO failures into something that can be thrown, to better integrate with Scala exception handling.
Fiber's counterpart for Java's ThreadLocal.
Fiber's counterpart for Java's ThreadLocal. Value is automatically propagated
to child on fork and merged back in after joining child.
for { fiberRef <- FiberRef.make("Hello world!") child <- fiberRef.set("Hi!).fork result <- child.join } yield result
result will be equal to "Hi!" as changes done by child were merged on join.
FiberRef#make also allows specifying how the values will be combined when joining. By default this will use the value of the joined fiber. for { fiberRef <- FiberRef.make(0, math.max) child <- fiberRef.update(_ + 1).fork _ <- fiberRef.update(_ + 2) _ <- child.join value <- fiberRef.get } yield value }}}
value will be 2 as the value in the joined fiber is lower and we specified max as our combine function.
The trait Has[A] is used with ZIO environment to express an effect's
dependency on a service of type A.
The trait Has[A] is used with ZIO environment to express an effect's
dependency on a service of type A. For example,
RIO[Has[Console.Service], Unit] is an effect that requires a
Console.Service service. Inside the ZIO library, type aliases are provided
as shorthands for common services, e.g.:
type Console = Has[ConsoleService]
Services parameterized on path dependent types are not supported.
The InterruptStatus of a fiber determines whether or not it can be
interrupted.
The InterruptStatus of a fiber determines whether or not it can be
interrupted. The status can change over time in different regions.
A value of type NeedsEnv[R] provides implicit evidence that an effect with
environment type R needs an environment, that is, that R is not equal to
Any.
A value of type NeedsEnv[R] provides implicit evidence that an effect with
environment type R needs an environment, that is, that R is not equal to
Any.
A NonEmptyChunk is a Chunk that is guaranteed to contain at least one
element.
A NonEmptyChunk is a Chunk that is guaranteed to contain at least one
element. As a result, operations which would not be safe when performed on
Chunk, such as head or reduce, are safe when performed on
NonEmptyChunk. Operations on NonEmptyChunk which could potentially
return an empty chunk will return a Chunk instead.
A promise represents an asynchronous variable, of zio.IO type, that can
be set exactly once, with the ability for an arbitrary number of fibers to
suspend (by calling await) and automatically resume when the variable is
set.
A promise represents an asynchronous variable, of zio.IO type, that can
be set exactly once, with the ability for an arbitrary number of fibers to
suspend (by calling await) and automatically resume when the variable is
set.
Promises can be used for building primitive actions whose completions require the coordinated action of multiple fibers, and for building higher-level concurrent or asynchronous structures.
for { promise <- Promise.make[Nothing, Int] _ <- promise.succeed(42).delay(1.second).fork value <- promise.await // Resumes when forked fiber completes promise } yield value
A Reservation[-R, +E, +A] encapsulates resource acquisition and disposal
without specifying when or how that resource might be used.
A Reservation[-R, +E, +A] encapsulates resource acquisition and disposal
without specifying when or how that resource might be used.
See ZManaged#reserve and ZIO#reserve for details of usage.
A Runtime[R] is capable of executing tasks within an environment R.
Defines a stateful, possibly effectful, recurring schedule of actions.
Defines a stateful, possibly effectful, recurring schedule of actions.
A Schedule[R, A, B] consumes A values, and based on the inputs and the
internal state, decides whether to continue or halt. Every decision is
accompanied by a (possibly zero) delay, and an output value of type B.
Schedules compose in each of the following ways:
1. Intersection, using the && operator, which requires that both schedules
continue, using the longer of the two durations.
2. Union, using the || operator, which requires that only one schedule
continues, using the shorter of the two durations.
3. Sequence, using the <||> operator, which runs the first schedule until
it ends, and then switches over to the second schedule.
Schedule[R, A, B] forms a profunctor on [A, B], an applicative functor on
B, and a monoid, allowing rich composition of different schedules.
An asynchronous semaphore, which is a generalization of a mutex.
An asynchronous semaphore, which is a generalization of a mutex. Semaphores have a certain number of permits, which can be held and released concurrently by different parties. Attempts to acquire more permits than available result in the acquiring fiber being suspended until the specified number of permits become available.
A Supervisor[A] is allowed to supervise the launching and termination of
fibers, producing some visible value of type A from the supervision.
Whether ZIO Tracing is enabled for the current fiber in the current region.
A ZIO[R, E, A] value is an immutable value that lazily describes a
workflow or job.
A ZIO[R, E, A] value is an immutable value that lazily describes a
workflow or job. The workflow requires some environment R, and may fail
with an error of type E, or succeed with a value of type A.
These lazy workflows, referred to as _effects_, can be informally thought of as functions in the form:
R => Either[E, A]ZIO effects model resourceful interaction with the outside world, including synchronous, asynchronous, concurrent, and parallel interaction.
ZIO effects use a fiber-based concurrency model, with built-in support for scheduling, fine-grained interruption, structured concurrency, and high scalability.
To run an effect, you need a Runtime, which is capable of executing effects.
Runtimes bundle a thread pool together with the environment that effects need.
A ZLayer[A, E, B] describes a layer of an application: every layer in an
application requires some services (the input) and produces some services
(the output).
A ZLayer[A, E, B] describes a layer of an application: every layer in an
application requires some services (the input) and produces some services
(the output).
Layers can be thought of as recipes for producing bundles of services, given their dependencies (other services).
Construction of layers can be effectful and utilize resources that must be acquired and safely released when the services are done being utilized.
By default layers are shared, meaning that if the same layer is used twice the layer will only be allocated a single time.
Because of their excellent composition properties, layers are the idiomatic way in ZIO to create services that depend on other services.
A ZManaged[R, E, A] is a managed resource of type A, which may be used by
invoking the use method of the resource.
A ZManaged[R, E, A] is a managed resource of type A, which may be used by
invoking the use method of the resource. The resource will be automatically
acquired before the resource is used, and automatically released after the
resource is used.
Resources do not survive the scope of use, meaning that if you attempt to
capture the resource, leak it from use, and then use it after the resource
has been consumed, the resource will not be valid anymore and may fail with
some checked error, as per the type of the functions provided by the resource.
A ZQueue[RA, RB, EA, EB, A, B] is a lightweight, asynchronous queue into which values of
type A can be enqueued and of which elements of type B can be dequeued.
A ZQueue[RA, RB, EA, EB, A, B] is a lightweight, asynchronous queue into which values of
type A can be enqueued and of which elements of type B can be dequeued. The queue's
enqueueing operations may utilize an environment of type RA and may fail with errors of
type EA. The dequeueing operations may utilize an environment of type RB and may fail
with errors of type EB.
A ZRef[EA, EB, A, B] is a polymorphic, purely functional description of a
mutable reference.
A ZRef[EA, EB, A, B] is a polymorphic, purely functional description of a
mutable reference. The fundamental operations of a ZRef are set and
get. set takes a value of type A and sets the reference to a new
value, potentially failing with an error of type EA. get gets the
current value of the reference and returns a value of type B, potentially
failing with an error of type EB.
When the error and value types of the ZRef are unified, that is, it is a
ZRef[E, E, A, A], the ZRef also supports atomic modify and update
operations. All operations are guaranteed to be safe for concurrent access.
NOTE: While ZRef provides the functional equivalent of a mutable
reference, the value inside the ZRef should be immutable. For performance
reasons ZRef is implemented in terms of compare and swap operations rather
than synchronization. These operations are not safe for mutable values that
do not support concurrent access.
A ZRefM[RA, RB, EA, EB, A, B] is a polymorphic, purely functional
description of a mutable reference.
A ZRefM[RA, RB, EA, EB, A, B] is a polymorphic, purely functional
description of a mutable reference. The fundamental operations of a ZRefM
are set and get. set takes a value of type A and sets the reference
to a new value, requiring an environment of type RA and potentially
failing with an error of type EA. get gets the current value of the
reference and returns a value of type B, requiring an environment of type
RB and potentially failing with an error of type EB.
When the error and value types of the ZRefM are unified, that is, it is a
ZRefM[E, E, A, A], the ZRefM also supports atomic modify and update
operations.
Unlike ZRef, ZRefM allows performing effects within update operations,
at some cost to performance. Writes will semantically block other writers,
while multiple readers can read simultaneously.
A ZScope[A] is a value that allows adding finalizers identified by a key.
A ZScope[A] is a value that allows adding finalizers identified by a key.
Scopes are closed with a value of type A, which is provided to all the
finalizers when the scope is released.
For safety reasons, this interface has no method to close a scope. Rather,
an open scope may be required with ZScope.make, which returns a function
that can close a scope. This allows scopes to be safely passed around
without fear they will be accidentally closed.
(Since version 1.0.0) use Tag
(Since version 1.0.0) use TagK
(Since version 1.0.0) use TagK10
(Since version 1.0.0) use TagK11
(Since version 1.0.0) use TagK12
(Since version 1.0.0) use TagK13
(Since version 1.0.0) use TagK14
(Since version 1.0.0) use TagK15
(Since version 1.0.0) use TagK16
(Since version 1.0.0) use TagK17
(Since version 1.0.0) use TagK18
(Since version 1.0.0) use TagK19
(Since version 1.0.0) use TagKK
(Since version 1.0.0) use TagK20
(Since version 1.0.0) use TagK21
(Since version 1.0.0) use TagK22
(Since version 1.0.0) use TagK3
(Since version 1.0.0) use TagK4
(Since version 1.0.0) use TagK5
(Since version 1.0.0) use TagK6
(Since version 1.0.0) use TagK7
(Since version 1.0.0) use TagK8
(Since version 1.0.0) use TagK9
(Since version 1.0.0) use LightTypeTag
This object was generated by sbt-buildinfo.