elemental library

Classes

AsyncContext<E, A>
Atom<T>
The base class for all atoms.
AtomConfigMixin<A extends Atom>
AtomContext<T>
Passed to the Atom.$read method, allowing you to interact with other atoms and manage the lifecycle of your state.
AtomInitialValue<A>
Returned from Atom.withInitialValue for passing to a AtomRegistry or AtomScope.
AtomRegistry
Responsible for mapping atom's to their state.
AtomWithParent<A, Parent extends Atom>
AtomWithParentBase<A, Parent extends Atom>
See atomWithParent.
CanBeEmpty
Your own classes can implement this so they may use CanBeEmptyExtension.
Cause<E>
Represents the error channel of a ZIO.
ConfigList
  • If isDeepEquals is false, the IList equals operator (==) compares by identity.
  • If isDeepEquals is true (the default), the IList equals operator (==) compares all items, ordered.
  • If cacheHashCode is true (the default), the IList will only calculate the hashCode once, when it is asked — initially, internally null. Otherwise, it will always recalculate it.
    • ConfigMap
  • If isDeepEquals is false, the IMap equals operator (==) compares by identity.
  • If isDeepEquals is true (the default), the IMap equals operator (==) compares all entries, ordered.
  • If sort is true, will sort the list output of keys. Otherwise, it will keep the insertion order (the default).
  • If cacheHashCode is true (the default), the IMap will only calculate the hashCode once, when it is asked — initially, internally null. Otherwise, it will always recalculate it.
    • ConfigMapOfSets
  • If isDeepEquals is false, the IMap equals operator (==) compares by identity.
  • If isDeepEquals is true (the default), the IMap equals operator (==) compares all entries, ordered.
  • If sortKeys is true, will sort the list output of keys. Otherwise, it will keep the insertion order (the default).
  • If cacheHashCode is true (the default), the IMapOfSets will only calculate the hashCode once, when it is asked — initially, internally null. Otherwise, it will always recalculate it.
    • ConfigSet
    The set configuration.
    Defect<E>
    Represents an uncaught error.
    Deferred<E, A>
    A Deferred is represents a value that may not be available yet.
    Dequeue<A>
    DiffAndIntersectResult<T, G>
    DoContext<R, E>
    Either<L, R>
    Represents a value of one of two possible types, Left or Right.
    Enqueue<A>
    Entry<K, V>
    Similar to a MapEntry, but correctly implements equals (== comparing key and value), hashcode and Comparable.compareTo.
    Eq<T>
    A type class used to determine equality between 2 instances of the same type T. Any 2 instances x and y are equal if eqv(x, y) is true.
    Failure<E>
    Represents a failure with an error of type E.
    Fiber<R, E, A>
    While elemental does not have a fiber runtime, Fiber is used to abstract the running of ZIO's in the background.
    FutureData<A>
    Represents the case where an async operation succeeds, and has returned a some data.
    FutureError<A>
    Represents the case where an async operation fails, and has returned an error.
    FutureLoading<A>
    Represents the case where an async operation is waiting for a result.
    FutureValue<A>
    Represents the loading, error and data state of an async operation.
    Guarded<A>
    A Guarded is a wrapper around a value that can only be accessed by a by the specified number of permits (defaults to 1), at any given time.
    Hash<T>
    A type class used to represent a hashing scheme for objects of a given type.
    HKT<G, A>
    https://marcosh.github.io/post/2020/04/15/higher-kinded-types-php-solution.html https://medium.com/@gcanti/higher-kinded-types-in-flow-275b657992b7
    HKT2<G1, G2, A>
    HKT3<G1, G2, G3, A>
    IList<T>
    An immutable list. Note: The replace method is the equivalent of operator []= for the IList.
    IListConst<T>
    This is an IList which can be made constant. Note: Don't ever use it without the "const" keyword, because it will be unsafe.
    IListOf2<T>
    An immutable list of only 2 items.
    IListOf3<T>
    An immutable list of only 3 items.
    IListOf4<T>
    An immutable list of only 4 items.
    IMap<K, V>
    An immutable, unordered map.
    IMapConst<K, V>
    This is an IMap which can be made constant. Note: Don't ever use it without the "const" keyword, because it will be unsafe.
    IMapOfSets<K, V>
    An immutable, unordered, map of sets.
    IMapOfSetsConst<K, V>
    ImmutableCollection<C>
    Interrupted<E>
    Interrupted is used to indicated that a ZIO was interrupted.
    ISet<T>
    An immutable, ordered set. It can be configured to order by insertion order, or sort.
    ISetConst<T>
    This is an ISet which can be made constant. Note: Don't ever use it without the "const" keyword, because it will be unsafe.
    Layer<E, Service>
    A Layer can be used to construct a service.
    LayerContext
    Left<L, R>
    ListMap<K, V>
    A ListMap is a mutable, fixed-sized, and ordered map.
    ListMapView<K, V>
    A ListMapView lets you view a regular map as if it was a ListMap. At the moment this class is for FIC's internal use only, since a lot of its methods will throw UnsupportedError.
    ListSet<T>
    A ListSet is, at the same time:
    ListSetView<T>
    Logger
    MapEntryEquality<E>
    This works for any object, not only map entries, but MapEntry gets special treatment. We consider two map-entries equal when their respective key and values are equal.
    MemoryNucleusStorage
    ModifiableListFromIList<T>
    The ModifiableListFromIList is a safe, modifiable List that is built from an IList. The construction of the list is fast at first, since it makes no copies of the IList items, but just uses it directly.
    ModifiableMapFromIMap<K, V>
    The ModifiableMapFromIMap is a safe, modifiable Map that is built from an IMap. The construction of the map is fast at first, since it makes no copies of the IMap items, but just uses it directly.
    ModifiableSetFromISet<T>
    The ModifiableSetFromISet is a safe, modifiable Set that is built from an ISet. The construction of the set is fast at first, since it makes no copies of the ISet items, but just uses it directly.
    NoEnv
    Represents the absence of an environment
    None
    NucleusStorage
    Option<T>
    A type that can contain a value of type T in a Some or no value with None.
    Order<T>
    The Order type class is used to define a total ordering on some type A.
    Output<T>
    Meant to be used when you wish to save a value that's going to be tossed out of an immutable collection.
    PartialOrder<T>
    The PartialOrder type class is used to define a partial ordering on some type A.
    ReadOnlyAtom<T>
    See atom.
    ReadOnlyAtomBase<Value>
    See atom.
    Ref<A>
    A Ref holds a value of type A and allows to modify it atomically.
    RefreshableAtomWithParent<A, Parent extends Atom>
    See atomWithParent.
    RefreshableReadOnlyAtom<T>
    See atom.
    RefreshableWritableAtom<R, W>
    Represents an Atom that can be written to.
    ReversedListView<T>
    Returns a List of the objects in this list in reverse order. Very efficient since it returns a view, which means if you change the original list this one will also change, and vice-versa.
    Runtime
    Schedule<R, E, I, O>
    ScheduleDriver<R, E, I, O>
    Scope<R>
    Semaphore
    A semaphore is a concurrency primitive that allows you to limit the number of concurrent operations.
    Some<T>
    StateAtom<R>
    Represents an Atom that can be written to.
    Unit
    Used instead of void as a return statement for a function when no value is to be returned.
    UnmodifiableListFromIList<T>
    The UnmodifiableListFromIList is a relatively safe, unmodifiable List view that is built from an IList or another List. The construction of the UnmodifiableListFromIList is very fast, since it makes no copies of the given list items, but just uses it directly.
    UnmodifiableMapFromIMap<K, V>
    The UnmodifiableMapFromIMap is a relatively safe, unmodifiable Map that is built from an IMap or another Map. The construction of the UnmodifiableMapFromIMap is very fast, since it makes no copies of the given map items, but just uses it directly.
    UnmodifiableSetFromISet<T>
    The UnmodifiableSetFromISet is a relatively safe, unmodifiable Set view that is built from an ISet or another Set. The construction of the UnmodifiableSetFromISet is very fast, since it makes no copies of the given set items, but just uses it directly.
    WritableAtom<R, W>
    Represents an Atom that can be written to.
    WritableAtomBase<R, W>
    Represents an Atom that can be written to.
    ZIO<R, E, A>
    Represents an operation that can fail with requirements
    ZIOContext<R>
    Represents the context in which a ZIO is executed.
    ZIOQueue<A>
    An asynchronous queue. It is backed by a ListQueue and a linked list of DeferredIOs.
    ZIORunner<E, A>
    ZIORunnerState<E, A>

    Enums

    LogLevel

    Mixins

    Alt<KT, A>
    Alt type class identifies an associative operation on a type constructor.
    Alt2<KT, A, B>
    Alt3<KT, P1, P2, P3>
    Applicative<G, A>
    Applicative2<G, A, B>
    Applicative3<G, A, B, C>
    Band<T>
    Bands are semigroups whose operation (i.e. combine) is also idempotent (an operation that can be applied multiple times without changing the result beyond the initial application).
    BoundedSemilattice<T>
    A semilattice in which:
    CommutativeGroup<T>
    An commutative group (also known as an abelian group) is a group whose combine operation is commutative.
    CommutativeMonoid<T>
    CommutativeMonoid represents a commutative monoid.
    CommutativeSemigroup<T>
    CommutativeSemigroup represents a commutative semigroup.
    Extend<KT, A>
    Extend2<KT, A, B>
    Filterable<KT, A>
    Foldable<G, A>
    Foldable2<G, A, B>
    FromIListMixin<T, I extends FromIListMixin<T, I>>
    This mixin implements all IList methods (without config (ConfigList)), plus operator [], but it does NOT implement Iterable nor IList.
    FromISetMixin<T, I extends FromISetMixin<T, I>>
    This mixin implements all ISet members (without config), but it does NOT implement Iterable nor ISet.
    FromIterableIListMixin<T>
    This mixin implements all Iterable methods, plus operator [], but it does NOT implement Iterable nor IList.
    FromIterableISetMixin<T>
    This mixin implements all Iterable methods, but it does NOT implement Iterable nor ISet.
    Functor<G, A>
    Functor<G, A> extends HKT<G, A> to express the fact that the classes implementing the Functor interface will need to be higher kinded types.
    Functor2<G, A, B>
    Functor3<G, A, B, C>
    Group<T>
    A group is a monoid where each element has an inverse.
    Monad<KT, A>
    Monad2<KT, A, B>
    Monad3<KT, P1, P2, P3>
    Monoid<T>
    A monoid is a semigroup with an identity (empty).
    RefreshableAtom
    RefreshableAtomMixin<A extends RefreshableAtom>
    ScopeMixin
    Semigroup<T>
    A semigroup is any set A with an associative operation (combine).
    Semilattice<T>
    Semilattices are commutative semigroups whose operation (i.e. combine) is also idempotent.

    Extensions

    AtomExtension on Atom<A>
    ChainExtension on T
    ComposeExtension0 on A Function()
    ComposeExtension1 on B Function(A)
    ComposeExtension2 on C Function(A, B)
    ComposeExtension3 on D Function(A, B, C)
    ComposeExtension4 on E Function(A, B, C, D)
    CurryExtension2 on Output Function(Input1, Input2)
    Extract first parameter from this function to allow curring.
    CurryExtension3 on Output Function(Input1, Input2, Input3)
    CurryExtension4 on Output Function(Input1, Input2, Input3, Input4)
    CurryExtension5 on Output Function(Input1, Input2, Input3, Input4, Input5)
    EIOLiftExt on EIO<E, A>
    EIORunnerExt on EIO<E, A>
    EitherExitExt on Either<E, A>
    ExitExt on Exit<E, A>
    FicBooleanExtension on bool
    See also: compareObject, FicComparableExtension, FicComparatorExtension, sortBy, sortLike
    FicComparableExtension on Object?
    FicComparatorExtension on int
    The if0 extension lets you nest comparators. For example:
    FicIterableExtension on Iterable<T>
    See also: FicListExtension, FicSetExtension
    FicIterableExtensionTypeNullable on Iterable<T?>
    See also: FicListExtension, FicSetExtension
    FicIterableOfMapEntryExtension on Iterable<MapEntry<K, V>>
    FicIteratorExtension on Iterator<T>
    See also: FicIterableExtension
    FicListExtension on List<T>
    FicListExtensionNullable on List<T?>
    FicMapEntryExtension on MapEntry<K, V>
    FicMapExtension on Map<K, V>
    See also: FicMapOfSetsExtension
    FicMapIteratorExtension on Iterator<MapEntry<K, V>>
    See also: FicIterableExtension, FicIteratorExtension
    FicMapOfSetsExtension on Map<K, Set<V>>
    See also: FicMapExtension
    FicNumberExtension on T
    FicNumberExtensionNullable on T?
    FicObjectExtension on Object?
    FicSetExtension on Set<T>
    See also: FicListExtension
    FICZipExtension on Iterable<Tuple2<U, V>>
    FpdartOnDateTime on DateTime
    fpdart extension methods on DateTime
    FpdartOnIterable on Iterable<T>
    Get the first element of the Iterable. If the Iterable is empty, return None. Functional programming functions on a mutable dart Iterable using fpdart.
    FpdartOnIterableOfIterable on Iterable<Iterable<T>>
    Functional programming functions on Iterable<Iterable<T>> using fpdart.
    FpdartOnList on List<T>
    Functional programming functions on a mutable dart Iterable using fpdart.
    FpdartOnMap on Map<K, V>
    Functional programming functions on a mutable dart Map using fpdart.
    FpdartOnOption on Option<T>
    FpdartOnOptionMap on Option<Map<K, dynamic>>
    FpdartOnPredicate on bool Function()
    FpdartOnPredicate1 on bool Function(P)
    FpdartOnString on String
    Functional programming functions on dart String using fpdart.
    FpdartSequenceIterableEither on Iterable<Either<E, A>>
    FpdartSequenceIterableIO on Iterable<IO<T>>
    FpdartSequenceIterableIOEither on Iterable<IOEither<E, T>>
    FpdartSequenceIterableIOOption on Iterable<IOOption<T>>
    FpdartSequenceIterableOption on Iterable<Option<T>>
    FpdartSequenceIterableTask on Iterable<Task<T>>
    FpdartSequenceIterableTaskEither on Iterable<TaskEither<E, T>>
    FpdartSequenceIterableTaskOption on Iterable<TaskOption<T>>
    FpdartTraversableIterable on Iterable<T>
    FutureValueAtomExtension on Atom<FutureValue<A>>
    FutureValueAtomWithParentExtension on AtomWithParentBase<FutureValue<A>, Parent>
    IOLiftExt on IO<A>
    RIOLiftExt on RIO<R, A>
    SchedultLiftEIOExt on Schedule<NoEnv, E, dynamic, O>
    SchedultLiftIOExt on Schedule<NoEnv, Never, dynamic, O>
    SchedultLiftRIOExt on Schedule<R, Never, dynamic, O>
    UncurryExtension2 on Output Function(Input2) Function(Input1)
    UncurryExtension3 on Output Function(Input3) Function(Input2) Function(Input1)
    UncurryExtension4 on Output Function(Input4) Function(Input3) Function(Input2) Function(Input1)
    UncurryExtension5 on Output Function(Input5) Function(Input4) Function(Input3) Function(Input2) Function(Input1)
    ZIOAskExt on ZIO<NoEnv, E, A>
    ZIOAtomContextExt on AtomContext
    ZIOEitherExt on Either<E, A>
    ZIOFinalizerExt on ZIO<R, E, A>
    ZIOFinalizerNoEnvExt on ZIO<R, E, A>
    ZIOForkExt on ZIO<R, E, A>
    ZIOIterableExt on Iterable<ZIO<R, E, A>>
    ZIOLiftScopeExt on ZIO<Scope<NoEnv>, E, A>
    ZIONoneExt on RIOOption<R, A>
    ZIOOptionExt on Option<A>
    ZIORunExt on EIO<E, A>
    ZIOScopeExt on ZIO<Scope<R>, E, A>

    Constants

    loggerAnnotationsSymbol → const Symbol
    unit → const Unit
    Used instead of void as a return statement for a function when no value is to be returned.

    Properties

    dateNow → IO<DateTime>
    Constructs a DateTime instance with current date and time in the local time zone.
    no setter
    ioRefEq → Eq<IORef<Object?>>
    Eq instance to compare IORefs using pointer equality
    final
    loggerLayer → Layer<Never, Logger>
    final
    logLevelLayer → Layer<Never, LogLevel>
    final
    now → IO<int>
    The number of milliseconds since the "Unix epoch" 1970-01-01T00:00:00Z (UTC).
    no setter
    runtimeAtom → ReadOnlyAtom<Runtime>
    The default Runtime used by used by zioRefAtomSync and zioAtom. Also used by the extension methods on AtomContext and BuildContext.
    final

    Functions

    areImmutableCollectionsWithEqualItems(ImmutableCollection? c1, ImmutableCollection? c2) → bool
    Will return true only if the collections are of the same type, and their items are equal by calling the collection's equalItems method. This may be slow for very large collection, since it compares each item, one by one. Note this will not compare the collection configuration.
    areSameImmutableCollection(ImmutableCollection? c1, ImmutableCollection? c2) → bool
    While identical(collection1, collection2) will compare the collections by identity, areSameImmutableCollection(collection1, collection2) will compare them by type, and then by their internal state. Note this is practically as fast as identical, but will give less false negatives. So it is almost always recommended to use areSameImmutableCollection instead of identical.
    atom<Value>(AtomReader<Value> create) → ReadOnlyAtom<Value>
    Create a read only atom that can interact with other atom's to create derived state.
    atomFamily<A extends Atom, Arg>(A create(Arg arg)) → A Function(Arg arg)
    Create a family factory function, for indexing similar atoms with the Arg type.
    atomIdMap<T, Id, A extends Atom<T>>(A create(T item), {required Id id(T item)}) → Map<Id, A> Function(Iterable<T> items)
    atomWithParent<A, Parent extends Atom>(Parent parent, A create(AtomContext<A> get, Parent parent)) → AtomWithParent<A, Parent>
    Create an Atom that is linked to a parent Atom.
    atomWithStorage<R, A>(AtomWithStorageCreate<R, A> create, {required String key, required Atom<NucleusStorage> storage, required A fromJson(dynamic json), required dynamic toJson(A a)}) → ReadOnlyAtom<R>
    Create an atom that can read and write to a NucleusStorage instance.
    boolAndMonoid() → Monoid<bool>
    boolOrMonoid() → Monoid<bool>
    combineIterables<A, B, R>(Iterable<A> a, Iterable<B> b, R combine(A, B), {bool allowDifferentSizes = false}) → Iterable<R>
    Combines iterables a and b into one, by applying the combine function. If allowDifferentSizes is true, it will stop as soon as one of the iterables has no more values. If allowDifferentSizes is false, it will throw an error if the iterables have different length.
    compareObject<T extends Object>(Object? a, Object? b, {bool nullsBefore = false}) → int
    The compareObject comparator is similar to the natural comparator provided by Comparable objects in their Comparable.compareTo method, to sort objects in their "natural order". The difference here is that compareObject is also able to compare some objects which are not Comparable, such as bool, MapEntry, Enum, and nulls.
    constF<A>(A a) → A Function(dynamic b)
    constf a is a unary function which evaluates to a for all inputs.
    dualEndoMonoid<A>() → Monoid<Endo<A>>
    endoMonoid<A>() → Monoid<Endo<A>>
    futureAtom<A>(AtomReader<Future<A>> create) → FutureAtom<A>
    Create an AtomWithParent that returns a FutureValue representing the current state of the Future's execution.
    identity<T>(T a) → T
    Returns the given a.
    identityFuture<T>(T a) → Future<T>
    Returns the given a, wrapped in Future.value.
    left<L, R>(L l) → Either<L, R>
    Return a Left(l).
    memo1<A, R>(R f(A)) → R Function(A)
    memo-ize the given function, caching the return result.
    memo2<A, B, R>(R f(A, B)) → R Function(A, B)
    memo-ize the given function, caching the return result.
    memo3<A, B, C, R>(R f(A, B, C)) → R Function(A, B, C)
    memo-ize the given function, caching the return result.
    memo4<A, B, C, D, R>(R f(A, B, C, D)) → R Function(A, B, C, D)
    memo-ize the given function, caching the return result.
    modifyIORef<T>(Endo<T> update, IORef<T> ref) → IO<Unit>
    Works almost identical to the write method, but instead of taking a value that needs to be written, takes an Endo function, applies the IORef's current value to it and writes the result to the IORef.
    modifyIORefC<T>(Endo<T> update) → IO<Unit> Function(IORef<T> ref)
    A curried version of the modifyIORef
    newIORef<T>(T initial) → IO<IORef<T>>
    Creates a new IORef inside an IO monad with a given initial value.
    none<T>() → Option<T>
    Return a None.
    option<T>(T value, bool predicate(T)) → Option<T>
    Return Some of value when predicate applied to value returns true, None otherwise.
    optionOf<T>(T? t) → Option<T>
    Return None if t is null, Some otherwise.
    readIORef<T>(IORef<T> ref) → IO<T>
    Extracts a current value of the IORef and returns it inside the IO monad.
    Return a Right(r).
    some<T>(T t) → Option<T>
    Return a Some(t).
    sortBy<T>(Predicate<T> test, {int then(T, T)?}) → int Function(T, T)
    The sortBy function can be used to create a comparator to sort collections, comparing a and b such that:
    sortLike<T, E>(Iterable<E> order, {E mapper(T)?, int then(T, T)?}) → int Function(T, T)
    The sortLike function can be used to create a comparator to sort collections, comparing a and b such that:
    stateAtom<Value>(Value initialValue) → WritableAtom<Value, Value>
    Create a simple atom with mutable state.
    stateAtomWithStorage<A>(A initialValue, {required Atom<NucleusStorage> storage, required String key, required A fromJson(dynamic json), required dynamic toJson(A a)}) → WritableAtom<A, A>
    Create a stateAtom, except it's value is persisted to a NucleusStorage instance.
    streamAtom<A>(AtomReader<Stream<A>> create, {A? initialValue}) → StreamAtom<A>
    toBoolEither<L>(String str, L onLeft()) → Either<L, bool>
    Convert this String to bool, returns the result of onLeft for invalid inputs.
    toBoolOption(String str) → Option<bool>
    Convert this String to bool, returns None for invalid inputs.
    toDoubleEither<L>(L onLeft()) → Either<L, double> Function(String)
    Convert this String to double, returns the result of onLeft for invalid inputs.
    toDoubleOption(String str) → Option<double>
    Convert this String to double, returns None for invalid inputs.
    toIntEither<L>(L onLeft()) → Either<L, int> Function(String)
    Convert this String to int, returns the result of onLeft for invalid inputs.
    toIntOption(String str) → Option<int>
    Convert this String to int, returns None for invalid inputs.
    toNumEither<L>(L onLeft()) → Either<L, num> Function(String)
    Convert this String to num, returns the result of onLeft for invalid inputs.
    toNumOption(String str) → Option<num>
    Convert this String to num, returns None for invalid inputs.
    weakAtomFamily<A extends Atom, Arg>(A create(Arg arg)) → A Function(Arg arg)
    Alternate version of atomFamily that holds a weak reference to each child.
    writableAtom<R, W>(AtomReader<R> reader, AtomWriter<R, W> writer) → WritableAtom<R, W>
    Creates an WritableAtom that can be used to implement custom write logic.
    writeIORef<T>(T value, IORef<T> ref) → IO<Unit>
    Writes the given value to the IORef and returns a Unit inside the IO monad.
    writeIORefC<T>(T value) → IO<Unit> Function(IORef<T> ref)
    A curried version of the writeIORef
    zioAtom<E, A>(EIO<E, A> zio, {bool runImmediately = true}) → AtomWithParent<ZIORunnerState<E, A>, Atom<ZIORunner<E, A>>>
    Creates an Atom of ZIORunnerState's from the given ZIO.
    zioRefAtomSync<E, A>(EIO<E, Ref<A>> zio) → AtomWithParent<A, Atom<Ref<A>>>
    Creates an Atom from a Ref contained in a ZIO. It will throw an error if the Ref cannot be accessed synchronously.

    Typedefs

    AtomReader<R> = R Function(AtomContext<R> get)
    A function that creates a value from an AtomContext
    AtomWithStorageCreate<R, A> = R Function(AtomContext<R> get, A? read(), void write(A value))
    AtomWriter<R, W> = void Function(GetAtom get, SetAtom set, SetSelf<R> setSelf, W value)
    Represents the writer argument to writableAtom
    DeferredIO<A> = Deferred<Never, A>
    Represents a Deferred that can't fail.
    DoAdapterEither<L> = R Function<R>(Either<L, R>)
    DoAdapterIO = A Function<A>(IO<A>)
    DoAdapterIOEither<E> = A Function<A>(IOEither<E, A>)
    DoAdapterIOOption = A Function<A>(IOOption<A>)
    DoAdapterOption = A Function<A>(Option<A>)
    DoAdapterReaderTask<E> = Future<A> Function<A>(ReaderTask<E, A>)
    DoAdapterReaderTaskEither<E, L> = Future<A> Function<A>(ReaderTaskEither<E, L, A>)
    DoAdapterTask = Future<A> Function<A>(Task<A>)
    DoAdapterTaskEither<E> = Future<A> Function<A>(TaskEither<E, A>)
    DoAdapterTaskOption = Future<A> Function<A>(TaskOption<A>)
    DoFunction<R, E, A> = FutureOr<A> Function(DoContext<R, E> $, R env)
    A function that can be used in a ZIO.Do.
    DoFunctionEither<L, R> = R Function(DoAdapterEither<L> $)
    DoFunctionIO<A> = A Function(DoAdapterIO $)
    DoFunctionIOEither<L, A> = A Function(DoAdapterIOEither<L> $)
    DoFunctionIOOption<A> = A Function(DoAdapterIOOption $)
    DoFunctionOption<A> = A Function(DoAdapterOption $)
    DoFunctionReaderTask<E, A> = Future<A> Function(DoAdapterReaderTask<E> $)
    DoFunctionReaderTaskEither<E, L, A> = Future<A> Function(DoAdapterReaderTaskEither<E, L> $)
    DoFunctionTask<A> = Future<A> Function(DoAdapterTask $)
    DoFunctionTaskEither<L, A> = Future<A> Function(DoAdapterTaskEither<L> $)
    DoFunctionTaskOption<A> = Future<A> Function(DoAdapterTaskOption $)
    EIO<E, A> = ZIO<NoEnv, E, A>
    Represents an operation that can fail, with no requirements
    Endo<A> = A Function(A a)
    EQ<T, U> = bool Function(T item, U other)
    Exit<E, A> = Either<Cause<E>, A>
    The result of a ZIO computation.
    FutureAtom<A> = AtomWithParent<FutureValue<A>, Atom<Future<A>>>
    Represents an AtomWithParent for an async operation.
    GetAtom = A Function<A>(Atom<A> atom)
    Represents a function that retrieves an Atom's value.
    IO<A> = ZIO<NoEnv, Never, A>
    Represents an operation that cant fail, with no requirements
    IOOption<A> = ZIO<NoEnv, None, A>
    Represents an operation that represent an optional value
    Op<T> = T Function(T element)
    Operation of type that conserve the original type
    RIO<R, A> = ZIO<R, Never, A>
    Represents an operation that cant fail, with R requirements
    RIOOption<R, A> = ZIO<R, None, A>
    Represents an operation that represent an optional value
    Separated<KT, A, B> = (HKT<KT, A>, HKT<KT, B>)
    SetAtom = void Function<R, W>(WritableAtom<R, W> atom, W value)
    Represents a function that sets a WritableAtom's value.
    SetSelf<A> = void Function(A value)
    Represents function that sets the current atom's value
    StreamAtom<A> = AtomWithParent<FutureValue<A>, Atom<Stream<A>>>
    Represents an AtomWithParent for a streaming operation.