omlish 0.0.0.dev452__py3-none-any.whl → 0.0.0.dev454__py3-none-any.whl

omlish/funcs/guard.py

@@ -0,0 +1,225 @@
+import abc
+import functools
+import operator
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import lang
+
+
+T = ta.TypeVar('T')
+T_co = ta.TypeVar('T_co', covariant=True)
+U = ta.TypeVar('U')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class GuardFn(ta.Protocol[P, T_co]):
+    def __get__(self, instance, owner=None): ...
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T_co] | None: ...
+
+
+##
+
+
+@ta.final
+class DumbGuardFn(ta.Generic[P, T]):
+    def __init__(self, fn: ta.Callable[P, T]) -> None:
+        self._fn = fn
+
+    def __get__(self, instance, owner=None):
+        return DumbGuardFn(self._fn.__get__(instance, owner))  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T]:
+        return functools.partial(self._fn, *args, **kwargs)
+
+
+dumb = DumbGuardFn
+
+
+##
+
+
+class AmbiguousGuardFnError(Exception):
+    pass
+
+
+@ta.final
+class MultiGuardFn(ta.Generic[P, T]):
+    def __init__(
+            self,
+            *children: GuardFn[P, T],
+            default: GuardFn[P, T] | None = None,
+            strict: bool = False,
+    ) -> None:
+        self._children, self._default, self._strict = children, default, strict
+
+    lang.attr_ops(lambda self: (
+        self._children,
+        self._default,
+        self._strict,
+    )).install(locals())
+
+    def __get__(self, instance, owner=None):
+        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), default=self._default.__get__(instance, owner) if self._default is not None else None, strict=self._strict)  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
+        matches = []
+        for c in self._children:
+            if (m := c(*args, **kwargs)) is not None:
+                if not self._strict:
+                    return m
+                matches.append(m)
+        if not matches:
+            if (dfl := self._default) is not None:
+                return dfl(*args, **kwargs)
+            else:
+                return None
+        elif len(matches) > 1:
+            raise AmbiguousGuardFnError
+        else:
+            return matches[0]
+
+
+multi = MultiGuardFn
+
+
+##
+
+
+class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
+    def __init__(
+            self,
+            *,
+            strict: bool = False,
+            requires_override: bool = False,
+            instance_cache: bool = False,
+            default: GuardFn[P, T] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._strict = strict
+        self._instance_cache = instance_cache
+        self._default = default
+
+        self._registry: col.AttrRegistry[ta.Callable, None] = col.AttrRegistry(
+            requires_override=requires_override,
+        )
+
+        self._cache: col.AttrRegistryCache[ta.Callable, None, MultiGuardFn] = col.AttrRegistryCache(
+            self._registry,
+            self._prepare,
+        )
+
+    _owner: type | None = None
+    _name: str | None = None
+
+    def __set_name__(self, owner, name):
+        if self._owner is None:
+            self._owner = owner
+        if self._name is None:
+            self._name = name
+
+    def register(self, fn: U) -> U:
+        check.callable(fn)
+        self._registry.register(ta.cast(ta.Callable, fn), None)
+        return fn
+
+    def _prepare(self, instance_cls: type, collected: ta.Mapping[str, tuple[ta.Callable, None]]) -> MultiGuardFn:
+        return MultiGuardFn(
+            *[getattr(instance_cls, a) for a in collected],
+            default=self._default,
+            strict=self._strict,
+        )
+
+    @abc.abstractmethod
+    def _bind(self, instance, owner):
+        raise NotImplementedError
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+
+        if self._instance_cache:
+            try:
+                return instance.__dict__[self._name]
+            except KeyError:
+                pass
+
+        bound = self._bind(instance, owner)
+
+        if self._instance_cache:
+            instance.__dict__[self._name] = bound
+
+        return bound
+
+    def _call(self, *args, **kwargs):
+        instance, *rest = args
+        return self.__get__(instance)(*rest, **kwargs)
+
+#
+
+
+@ta.final
+class GuardFnMethod(_BaseGuardFnMethod[P, T]):
+    def _bind(self, instance, owner):
+        return self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
+        return self._call(*args, **kwargs)
+
+
+def method(
+        *,
+        strict: bool = False,
+        requires_override: bool = False,
+        instance_cache: bool = False,
+        default: bool = False,
+) -> ta.Callable[[ta.Callable[P, T]], GuardFnMethod[P, T]]:  # noqa
+    def inner(fn):
+        return GuardFnMethod(
+            strict=strict,
+            requires_override=requires_override,
+            instance_cache=instance_cache,
+            default=fn if default else None,
+        )
+
+    return inner
+
+
+#
+
+
+@ta.final
+class ImmediateGuardFnMethod(_BaseGuardFnMethod[P, T]):
+    def _bind(self, instance, owner):
+        gf = self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+        def inner(*args, **kwargs):
+            return gf(*args, **kwargs)()  # Note: cannot be None due to non-optional default
+
+        return inner
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self._call(*args, **kwargs)
+
+
+def immediate_method(
+        *,
+        strict: bool = False,
+        requires_override: bool = False,
+        instance_cache: bool = False,
+) -> ta.Callable[[ta.Callable[P, T]], ImmediateGuardFnMethod[P, T]]:  # noqa
+    def inner(fn):
+        return ImmediateGuardFnMethod(
+            strict=strict,
+            requires_override=requires_override,
+            instance_cache=instance_cache,
+            default=(lambda *args, **kwargs: lambda: fn(*args, **kwargs)),
+        )
+
+    return inner

omlish/graphs/dot/rendering.py

@@ -29,7 +29,7 @@ class Renderer:
 
         self._out = out
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, item: Item) -> None:
         raise TypeError(item)
 

omlish/lang/__init__.py

@@ -334,6 +334,7 @@ with _auto_proxy_init(globals(), update_exports=True):
         ilen,
         take,
         consume,
+        iterfrom,
         peek,
         chunk,
         interleave,

omlish/lang/iterables.py

@@ -26,6 +26,14 @@ def consume(it: ta.Iterable[ta.Any]) -> None:
     collections.deque(it, maxlen=0)
 
 
+def iterfrom(seq: ta.Sequence[T], start: int = 0, stop: int | None = None) -> ta.Iterator[T]:
+    if start < 0:
+        start += len(seq)
+    if stop is None:
+        stop = len(seq)
+    return map(seq.__getitem__, range(start, stop))
+
+
 def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     it = iter(vs)
     v = next(it)

omlish/lite/attrops.py

@@ -6,6 +6,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 import types  # noqa
 import typing as ta

omlish/lite/dataclasses.py

@@ -100,6 +100,36 @@ def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
 ##
 
 
+def dataclass_descriptor_method(*bind_attrs: str, bind_owner: bool = False) -> ta.Callable:
+    if not bind_attrs:
+        def __get__(self, instance, owner=None):  # noqa
+            return self
+
+    elif bind_owner:
+        def __get__(self, instance, owner=None):  # noqa
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    else:
+        def __get__(self, instance, owner=None):  # noqa
+            if instance is None:
+                return self
+
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    return __get__
+
+
+##
+
+
 def dataclass_kw_only_init():
     def inner(cls):
         if not isinstance(cls, type) and dc.is_dataclass(cls):

omlish/lite/maybes.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP007 UP045
 import abc
 import functools
+import operator
 import typing as ta
 
 from .abstract import Abstract
@@ -208,3 +209,10 @@ class _EmptyMaybe(_Maybe[T]):
 
 
 Maybe._empty = _EmptyMaybe()  # noqa
+
+
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))

omlish/marshal/__init__.py

@@ -113,10 +113,15 @@ with _lang.auto_proxy_init(globals()):
         OptionalUnmarshaler,
     )
 
-    from .composite.unions import (  # noqa
-        MatchUnionMarshaler,
-        MatchUnionUnmarshaler,
+    from .composite.unions.literals import (  # noqa
+        LITERAL_UNION_TYPES,
+        LiteralUnionMarshaler,
+        LiteralUnionMarshalerFactory,
+        LiteralUnionUnmarshaler,
+        LiteralUnionUnmarshalerFactory,
+    )
 
+    from .composite.unions.primitives import (  # noqa
         PRIMITIVE_UNION_TYPES,
         PrimitiveUnionMarshaler,
         PrimitiveUnionMarshalerFactory,
@@ -129,14 +134,9 @@ with _lang.auto_proxy_init(globals()):
         WrappedUnmarshaler,
     )
 
-    from .factories.simple import (  # noqa
-        SimpleMarshalerFactory,
-        SimpleUnmarshalerFactory,
-    )
-
-    from .factories.match import (  # noqa
-        MarshalerFactoryMatchClass,
-        UnmarshalerFactoryMatchClass,
+    from .factories.method import (  # noqa
+        MarshalerFactoryMethodClass,
+        UnmarshalerFactoryMethodClass,
     )
 
     from .factories.moduleimport.configs import (  # noqa
@@ -246,6 +246,7 @@ with _lang.auto_proxy_init(globals()):
 
     from .trivial.forbidden import (  # noqa
         ForbiddenTypeMarshalerFactory,
+        ForbiddenTypeMarshalerFactoryUnmarshalerFactory,
         ForbiddenTypeUnmarshalerFactory,
     )
 

omlish/marshal/base/contexts.py

@@ -5,7 +5,6 @@ from ... import check
 from ... import collections as col
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .configs import EMPTY_CONFIG_REGISTRY
 from .configs import ConfigRegistry
 from .errors import UnhandledTypeError
@@ -48,10 +47,9 @@ class MarshalContext(BaseContext, lang.Final):
     def make(self, o: ta.Any) -> 'Marshaler':
         rty = self._reflect(o)
         fac = check.not_none(self.factory)
-        try:
-            return fac.make_marshaler(self, rty)
-        except mfs.MatchGuardError:
+        if (mfn := fac.make_marshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
+        return mfn()
 
     def marshal(self, obj: ta.Any, ty: ta.Any | None = None) -> 'Value':
         return self.make(ty if ty is not None else type(obj)).marshal(self, obj)
@@ -64,10 +62,9 @@ class UnmarshalContext(BaseContext, lang.Final):
     def make(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
         fac = check.not_none(self.factory)
-        try:
-            return fac.make_unmarshaler(self, rty)
-        except mfs.MatchGuardError:
+        if (mfn := fac.make_unmarshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
+        return mfn()
 
     @ta.overload
     def unmarshal(self, v: 'Value', ty: type[T]) -> T:

omlish/marshal/base/funcs.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
+from ...funcs import guard as gfs
 from .contexts import MarshalContext
 from .contexts import UnmarshalContext
 from .types import Marshaler
@@ -39,19 +39,24 @@ class FuncUnmarshaler(Unmarshaler, lang.Final):
 
 @dc.dataclass(frozen=True)
 class FuncMarshalerFactory(MarshalerFactory):  # noqa
-    guard: ta.Callable[[MarshalContext, rfl.Type], bool]
-    fn: ta.Callable[[MarshalContext, rfl.Type], Marshaler]
+    gf: MarshalerMaker
 
-    @lang.cached_property
-    def make_marshaler(self) -> MarshalerMaker:
-        return mfs.simple(self.guard, self.fn)
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        return self.gf(ctx, rty)
 
 
 @dc.dataclass(frozen=True)
 class FuncUnmarshalerFactory(UnmarshalerFactory):  # noqa
-    guard: ta.Callable[[UnmarshalContext, rfl.Type], bool]
-    fn: ta.Callable[[UnmarshalContext, rfl.Type], Unmarshaler]
+    gf: UnmarshalerMaker
 
-    @lang.cached_property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return mfs.simple(self.guard, self.fn)
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self.gf(ctx, rty)
+
+
+##
+
+
+class GuardMethodMarshalerFactory(MarshalerFactory):
+    @gfs.method(instance_cache=True)
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        raise NotImplementedError

omlish/marshal/base/types.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
+from ...funcs import guard as gfs
 from .configs import ConfigRegistry
 from .contexts import MarshalContext
 from .contexts import UnmarshalContext
@@ -31,21 +31,19 @@ class Unmarshaler(lang.Abstract):
 ##
 
 
-MarshalerMaker: ta.TypeAlias = mfs.MatchFn[[MarshalContext, rfl.Type], Marshaler]
-UnmarshalerMaker: ta.TypeAlias = mfs.MatchFn[[UnmarshalContext, rfl.Type], Unmarshaler]
+MarshalerMaker: ta.TypeAlias = gfs.GuardFn[[MarshalContext, rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = gfs.GuardFn[[UnmarshalContext, rfl.Type], Unmarshaler]
 
 
 class MarshalerFactory(lang.Abstract):
-    @property
     @abc.abstractmethod
-    def make_marshaler(self) -> MarshalerMaker:
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         raise NotImplementedError
 
 
 class UnmarshalerFactory(lang.Abstract):
-    @property
     @abc.abstractmethod
-    def make_unmarshaler(self) -> UnmarshalerMaker:
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         raise NotImplementedError
 
 
@@ -98,3 +96,15 @@ class Marshaling(lang.Abstract):
     @ta.final
     def unmarshal(self, v, ty, **kwargs):
         return self.new_unmarshal_context(**kwargs).unmarshal(v, ty)
+
+
+##
+
+
+# MarshalerOrUnmarshaler: ta.TypeAlias = Marshaler | Unmarshaler
+# MarshalerOrUnmarshalerT = ta.TypeVar('MarshalerOrUnmarshalerT', bound=MarshalerOrUnmarshaler)
+#
+# MarshalContextOrUnmarshalContext: ta.TypeAlias = MarshalContext | UnmarshalContext
+# MarshalContextOrUnmarshalContextT = ta.TypeVar('MarshalContextOrUnmarshalContextT', bound=MarshalContextOrUnmarshalContext)  # noqa
+#
+# MarshalerMakerOrUnmarshalerMaker: ta.TypeAlias = MarshalerMaker | UnmarshalerMaker

omlish/marshal/composite/iterables.py

@@ -9,14 +9,13 @@ import typing as ta
 
 from ... import check
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
 from ..base.types import Unmarshaler
 from ..base.values import Value
-from ..factories.match import MarshalerFactoryMatchClass
-from ..factories.match import UnmarshalerFactoryMatchClass
+from ..factories.method import MarshalerFactoryMethodClass
+from ..factories.method import UnmarshalerFactoryMethodClass
 
 
 ##
@@ -29,6 +28,9 @@ DEFAULT_ITERABLE_CONCRETE_TYPES: dict[type[collections.abc.Iterable], type[colle
 }
 
 
+#
+
+
 @dc.dataclass(frozen=True)
 class IterableMarshaler(Marshaler):
     e: Marshaler
@@ -37,15 +39,21 @@ class IterableMarshaler(Marshaler):
         return list(map(functools.partial(self.e.marshal, ctx), o))
 
 
-class IterableMarshalerFactory(MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable))
-    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        return IterableMarshaler(ctx.make(check.single(gty.args)))
+class IterableMarshalerFactory(MarshalerFactoryMethodClass):
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_generic(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable)):
+            return None
+        return lambda: IterableMarshaler(ctx.make(check.single(rty.args)))
+
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, collections.abc.Iterable)):
+            return None
+        return lambda: IterableMarshaler(ctx.make(ta.Any))
+
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Iterable))
-    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return IterableMarshaler(ctx.make(ta.Any))
+#
 
 
 @dc.dataclass(frozen=True)
@@ -57,13 +65,16 @@ class IterableUnmarshaler(Unmarshaler):
         return self.ctor(map(functools.partial(self.e.unmarshal, ctx), check.isinstance(v, collections.abc.Iterable)))
 
 
-class IterableUnmarshalerFactory(UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable))
-    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        cty = DEFAULT_ITERABLE_CONCRETE_TYPES.get(gty.cls, gty.cls)  # noqa
-        return IterableUnmarshaler(cty, ctx.make(check.single(gty.args)))
+class IterableUnmarshalerFactory(UnmarshalerFactoryMethodClass):
+    @UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable)):
+            return None
+        cty = DEFAULT_ITERABLE_CONCRETE_TYPES.get(rty.cls, rty.cls)  # noqa
+        return lambda: IterableUnmarshaler(cty, ctx.make(check.single(rty.args)))  # noqa
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Iterable))
-    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return IterableUnmarshaler(check.isinstance(rty, type), ctx.make(ta.Any))
+    @UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, collections.abc.Iterable)):
+            return None
+        return lambda: IterableUnmarshaler(check.isinstance(rty, type), ctx.make(ta.Any))

omlish/marshal/composite/literals.py

@@ -10,10 +10,10 @@ from ... import reflect as rfl
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
 
 
 ##
@@ -28,14 +28,12 @@ class LiteralMarshaler(Marshaler):
         return self.e.marshal(ctx, check.in_(o, self.vs))
 
 
-class LiteralMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        lty = check.isinstance(rty, rfl.Literal)
-        ety = check.single(set(map(type, lty.args)))
-        return LiteralMarshaler(ctx.make(ety), frozenset(lty.args))
+class LiteralMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1):
+            return None
+        ety = check.single(set(map(type, rty.args)))
+        return lambda: LiteralMarshaler(ctx.make(ety), frozenset(rty.args))
 
 
 @dc.dataclass(frozen=True)
@@ -47,11 +45,9 @@ class LiteralUnmarshaler(Unmarshaler):
         return check.in_(self.e.unmarshal(ctx, v), self.vs)
 
 
-class LiteralUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        lty = check.isinstance(rty, rfl.Literal)
-        ety = check.single(set(map(type, lty.args)))
-        return LiteralUnmarshaler(ctx.make(ety), frozenset(lty.args))
+class LiteralUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Literal) and len(set(map(type, rty.args))) == 1):
+            return None
+        ety = check.single(set(map(type, rty.args)))
+        return lambda: LiteralUnmarshaler(ctx.make(ety), frozenset(rty.args))