LayerMapService

layer(lookup, *, idle_time_to_live=None, preload_keys=None) -> Layer[Self, Any, Any]

@classmethod
def layer(
    cls,
    lookup: Callable[[K], Layer[I, E, Any]],
    *,
    idle_time_to_live: IdleTimeToLive[K] | None = None,
    preload_keys: Iterable[K] | None = None,
) -> Layer[Self, Any, Any]:
    """A layer making the ``LayerMap`` (see ``LayerMap.make``). Provide
    its dependencies with ``.pipe(provide(...))``."""
    made: Effect[Any, Any, Any] = LayerMap.make(
        lookup, idle_time_to_live=idle_time_to_live, preload_keys=preload_keys
    )
    return layer_effect(cls, made)

layer_from_record(layers, *, idle_time_to_live=None, preload=False) -> Layer[Self, Any, Any]

@classmethod
def layer_from_record(
    cls,
    layers: Mapping[K, Layer[I, E, Any]],
    *,
    idle_time_to_live: IdleTimeToLive[K] | None = None,
    preload: bool = False,
) -> Layer[Self, Any, Any]:
    """A layer making the ``LayerMap`` with ``LayerMap.from_record``."""
    made: Effect[Any, Any, Any] = LayerMap.from_record(
        layers, idle_time_to_live=idle_time_to_live, preload=preload
    )
    return layer_effect(cls, made)

get(key) -> Layer[I, E, Self]

@classmethod
def get(cls, key: K) -> Layer[I, E, Self]:
    """A layer giving the services for ``key``, through this tag."""
    # Pyright can't solve ``unwrap``'s overloads against ``Self``.
    layer_of: Effect[Any, Any, Any] = cls._service().map(lambda m: m.get(key))
    return cast("Layer[I, E, Self]", unwrap(layer_of))

context_effect(key) -> Effect[Context[I], E, Scope | Self]

@classmethod
def context_effect(cls, key: K) -> Effect[Context[I], E, Scope | Self]:
    return cls._service().flat_map(lambda m: m.context_effect(key))

context_effect_option(key) -> Effect[Option[Context[I]], E, Scope | Self]

@classmethod
def context_effect_option(cls, key: K) -> Effect[Option[Context[I]], E, Scope | Self]:
    return cls._service().flat_map(lambda m: m.context_effect_option(key))

invalidate(key) -> Effect[None, Never, Self]

@classmethod
def invalidate(cls, key: K) -> Effect[None, Never, Self]:
    return cls._service().flat_map(lambda m: m.invalidate(key))