omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/marshal/base/configs.py

@@ -3,6 +3,10 @@ import typing as ta
 from ... import lang
 from .registries import Registry
 from .registries import RegistryItem
+from .registries import RegistryView
+
+
+ConfigT = ta.TypeVar('ConfigT', bound='Config')
 
 
 ##
@@ -12,7 +16,15 @@ class Config(RegistryItem, lang.Abstract):
     pass
 
 
+Configs: ta.TypeAlias = RegistryView[Config]
+
+
+##
+
+
 ConfigRegistry: ta.TypeAlias = Registry[Config]
 
+lang.static_check_issubclass[Configs](ConfigRegistry)
+
 
 EMPTY_CONFIG_REGISTRY = ConfigRegistry().seal()

omlish/marshal/base/contexts.py

@@ -5,9 +5,8 @@ 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 .configs import Configs
 from .errors import UnhandledTypeError
 from .options import Option
 from .overrides import ReflectOverride
@@ -28,44 +27,60 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class BaseContext(lang.Abstract):
-    config_registry: ConfigRegistry = EMPTY_CONFIG_REGISTRY
+class BaseContext(lang.Abstract, lang.Sealed):
+    configs: Configs = EMPTY_CONFIG_REGISTRY
     options: col.TypeMap[Option] = col.TypeMap()
 
     def _reflect(self, o: ta.Any) -> rfl.Type:
         def override(o):
-            if (ovr := self.config_registry.get_of(o, ReflectOverride)):
+            if (ovr := self.configs.get_of(o, ReflectOverride)):
                 return ovr[-1].rty
             return None
 
         return rfl.Reflector(override=override).type(o)
 
 
+#
+
+
 @dc.dataclass(frozen=True, kw_only=True)
-class MarshalContext(BaseContext, lang.Final):
-    factory: ta.Optional['MarshalerFactory'] = None
+class MarshalFactoryContext(BaseContext, lang.Final):
+    marshaler_factory: ta.Optional['MarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> 'Marshaler':
+    def make_marshaler(self, o: ta.Any) -> 'Marshaler':
         rty = self._reflect(o)
-        try:
-            return check.not_none(self.factory).make_marshaler(self, rty)
-        except mfs.MatchGuardError:
+        fac = check.not_none(self.marshaler_factory)
+        if (m := fac.make_marshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
-
-    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)
+        return m()
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class UnmarshalContext(BaseContext, lang.Final):
-    factory: ta.Optional['UnmarshalerFactory'] = None
+class UnmarshalFactoryContext(BaseContext, lang.Final):
+    unmarshaler_factory: ta.Optional['UnmarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> 'Unmarshaler':
+    def make_unmarshaler(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
-        try:
-            return check.not_none(self.factory).make_unmarshaler(self, rty)
-        except mfs.MatchGuardError:
+        fac = check.not_none(self.unmarshaler_factory)
+        if (m := fac.make_unmarshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
+        return m()
+
+
+#
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class MarshalContext(BaseContext, lang.Final):
+    marshal_factory_context: MarshalFactoryContext
+
+    def marshal(self, obj: ta.Any, ty: ta.Any | None = None) -> 'Value':
+        return self.marshal_factory_context.make_marshaler(ty if ty is not None else type(obj)).marshal(self, obj)
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class UnmarshalContext(BaseContext, lang.Final):
+    unmarshal_factory_context: UnmarshalFactoryContext
 
     @ta.overload
     def unmarshal(self, v: 'Value', ty: type[T]) -> T:
@@ -76,4 +91,4 @@ class UnmarshalContext(BaseContext, lang.Final):
         ...
 
     def unmarshal(self, v, ty):
-        return self.make(ty).unmarshal(self, v)
+        return self.unmarshal_factory_context.make_unmarshaler(ty).unmarshal(self, v)

omlish/marshal/base/funcs.py

@@ -3,9 +3,10 @@ import typing as ta
 
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .contexts import MarshalContext
+from .contexts import MarshalFactoryContext
 from .contexts import UnmarshalContext
+from .contexts import UnmarshalFactoryContext
 from .types import Marshaler
 from .types import MarshalerFactory
 from .types import MarshalerMaker
@@ -39,19 +40,15 @@ 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: MarshalFactoryContext, 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: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self.gf(ctx, rty)

omlish/marshal/base/options.py

@@ -1,2 +1,10 @@
+"""
+TODO:
+ - MarshalOption, UnmarshalOption, check if a context got something unexpected
+ - Options only apply to Factories?
+  - MarshalFactoryOption, MarshalOption, UnmarshalFactoryOption, MarshalOption ?
+"""
+
+
 class Option:
     pass

omlish/marshal/base/registries.py

@@ -3,11 +3,11 @@ TODO:
  - col.TypeMap?
   - at least get_any
 """
+import abc
 import dataclasses as dc
 import threading
 import typing as ta
 
-from ... import collections as col
 from ... import lang
 
 
@@ -22,23 +22,38 @@ RegistryItemT = ta.TypeVar('RegistryItemT', bound=RegistryItem)
 RegistryItemU = ta.TypeVar('RegistryItemU', bound=RegistryItem)
 
 
-@dc.dataclass(frozen=True)
-class _KeyRegistryItems(ta.Generic[RegistryItemT]):
-    key: ta.Any
-    items: list[RegistryItemT] = dc.field(default_factory=list)
-    item_lists_by_ty: dict[type[RegistryItemT], list[RegistryItemT]] = dc.field(default_factory=dict)
+##
+
+
+class RegistryView(lang.Abstract, ta.Generic[RegistryItemT]):
+    @abc.abstractmethod
+    def get(
+            self,
+            key: ta.Any,
+            *,
+            identity: bool | None = None,
+    ) -> ta.Sequence[RegistryItemT]:
+        ...
 
-    def add(self, *items: RegistryItemT) -> None:
-        for i in items:
-            self.items.append(i)
-            self.item_lists_by_ty.setdefault(type(i), []).append(i)
+    @abc.abstractmethod
+    def get_of(
+            self,
+            key: ta.Any,
+            item_ty: type[RegistryItemU],
+            *,
+            identity: bool | None = None,
+    ) -> ta.Sequence[RegistryItemU]:
+        ...
+
+
+##
 
 
 class RegistrySealedError(Exception):
     pass
 
 
-class Registry(ta.Generic[RegistryItemT]):
+class Registry(RegistryView[RegistryItemT]):
     def __init__(
             self,
             *,
@@ -50,14 +65,123 @@ class Registry(ta.Generic[RegistryItemT]):
             lock = threading.RLock()
         self._lock = lock
 
-        self._dct: dict[ta.Any, _KeyRegistryItems[RegistryItemT]] = {}
-        self._id_dct: ta.MutableMapping[ta.Any, _KeyRegistryItems[RegistryItemT]] = col.IdentityKeyDict()
+        self._state: Registry._State[RegistryItemT] = Registry._State(
+            dct={},
+            id_dct={},
+            version=0,
+        )
 
-        self._version = 0
         self._sealed = False
 
     #
 
+    @dc.dataclass(frozen=True)
+    class _KeyItems(ta.Generic[RegistryItemU]):
+        key: ta.Any
+        items: ta.Sequence[RegistryItemU] = ()
+        item_lists_by_ty: ta.Mapping[type[RegistryItemU], ta.Sequence[RegistryItemU]] = dc.field(default_factory=dict)
+
+        def add(self, *items: RegistryItemU) -> 'Registry._KeyItems[RegistryItemU]':
+            item_lists_by_ty: dict[type[RegistryItemU], list[RegistryItemU]] = {}
+
+            for i in items:
+                try:
+                    l = item_lists_by_ty[type(i)]
+                except KeyError:
+                    l = item_lists_by_ty[type(i)] = list(self.item_lists_by_ty.get(type(i), ()))
+                l.append(i)
+
+            return Registry._KeyItems(
+                self.key,
+                (*self.items, *items),
+                {**self.item_lists_by_ty, **item_lists_by_ty},
+            )
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class _State(ta.Generic[RegistryItemU]):
+        dct: ta.Mapping[ta.Any, 'Registry._KeyItems[RegistryItemU]']
+        id_dct: ta.Mapping[ta.Any, 'Registry._KeyItems[RegistryItemU]']
+        version: int
+
+        #
+
+        def register(
+                self,
+                key: ta.Any,
+                *items: RegistryItemT,
+                identity: bool = False,
+        ) -> 'Registry._State[RegistryItemU]':
+            if not items:
+                return self
+
+            sr_dct: ta.Any = self.dct if not identity else self.id_dct
+            if (sr := sr_dct.get(key)) is None:
+                sr = Registry._KeyItems(key)
+            sr = sr.add(*items)
+            new = {key: sr}
+
+            return Registry._State(
+                dct={**self.dct, **new} if not identity else self.dct,
+                id_dct={**self.id_dct, **new} if identity else self.id_dct,
+                version=self.version + 1,
+            )
+
+        #
+
+        _get_cache: dict[ta.Any, ta.Sequence[RegistryItem]] = dc.field(default_factory=dict)
+
+        def get(
+                self,
+                key: ta.Any,
+                *,
+                identity: bool | None = None,
+        ) -> ta.Sequence[RegistryItem]:
+            if identity is None:
+                try:
+                    return self._get_cache[key]
+                except KeyError:
+                    pass
+
+                ret = self._get_cache[key] = (
+                    *self.get(key, identity=True),
+                    *self.get(key, identity=False),
+                )
+                return ret
+
+            dct: ta.Any = self.dct if not identity else self.id_dct
+            try:
+                return dct[key].items
+            except KeyError:
+                return ()
+
+        _get_of_cache: dict[ta.Any, dict[type, ta.Sequence[RegistryItem]]] = dc.field(default_factory=dict)
+
+        def get_of(
+                self,
+                key: ta.Any,
+                item_ty: type[RegistryItem],
+                *,
+                identity: bool | None = None,
+        ) -> ta.Sequence[RegistryItem]:
+            if identity is None:
+                try:
+                    return self._get_of_cache[key][item_ty]
+                except KeyError:
+                    pass
+
+                ret = self._get_of_cache.setdefault(key, {})[item_ty] = (
+                    *self.get_of(key, item_ty, identity=True),
+                    *self.get_of(key, item_ty, identity=False),
+                )
+                return ret
+
+            dct: ta.Any = self.dct if not identity else self.id_dct
+            try:
+                sr = dct[key]
+            except KeyError:
+                return ()
+            return sr.item_lists_by_ty.get(item_ty, ())
+
     def is_sealed(self) -> bool:
         if self._sealed:
             return True
@@ -92,12 +216,11 @@ class Registry(ta.Generic[RegistryItemT]):
             if self._sealed:
                 raise RegistrySealedError(self)
 
-            dct: ta.Any = self._id_dct if identity else self._dct
-            if (sr := dct.get(key)) is None:
-                sr = dct[key] = _KeyRegistryItems(key)
-            sr.add(*items)
-
-            self._version += 1
+            self._state = self._state.register(
+                key,
+                *items,
+                identity=identity,
+            )
 
         return self
 
@@ -108,18 +231,8 @@ class Registry(ta.Generic[RegistryItemT]):
             key: ta.Any,
             *,
             identity: bool | None = None,
-    ) -> ta.Sequence[RegistryItem]:
-        if identity is None:
-            return (
-                *self.get(key, identity=True),
-                *self.get(key, identity=False),
-            )
-
-        dct: ta.Any = self._id_dct if identity else self._dct
-        try:
-            return dct[key].items
-        except KeyError:
-            return ()
+    ) -> ta.Sequence[RegistryItemT]:
+        return self._state.get(key, identity=identity)  # type: ignore [return-value]
 
     def get_of(
             self,
@@ -128,15 +241,4 @@ class Registry(ta.Generic[RegistryItemT]):
             *,
             identity: bool | None = None,
     ) -> ta.Sequence[RegistryItemU]:
-        if identity is None:
-            return (
-                *self.get_of(key, item_ty, identity=True),
-                *self.get_of(key, item_ty, identity=False),
-            )
-
-        dct: ta.Any = self._id_dct if identity else self._dct
-        try:
-            sr = dct[key]
-        except KeyError:
-            return ()
-        return sr.item_lists_by_ty.get(item_ty, ())
+        return self._state.get_of(key, item_ty, identity=identity)  # type: ignore [return-value]

omlish/marshal/base/types.py

@@ -3,10 +3,12 @@ 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 MarshalFactoryContext
 from .contexts import UnmarshalContext
+from .contexts import UnmarshalFactoryContext
 from .values import Value
 
 
@@ -31,21 +33,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[[MarshalFactoryContext, rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = gfs.GuardFn[[UnmarshalFactoryContext, rfl.Type], Unmarshaler]
 
 
 class MarshalerFactory(lang.Abstract):
-    @property
     @abc.abstractmethod
-    def make_marshaler(self) -> MarshalerMaker:
+    def make_marshaler(self, ctx: MarshalFactoryContext, 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: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
         raise NotImplementedError
 
 
@@ -65,20 +65,32 @@ class Marshaling(lang.Abstract):
     def unmarshaler_factory(self) -> UnmarshalerFactory:
         raise NotImplementedError
 
-    #
+    ##
+
+    def new_marshal_factory_context(self) -> MarshalFactoryContext:
+        return MarshalFactoryContext(
+            configs=self.config_registry(),
+            marshaler_factory=self.marshaler_factory(),
+        )
+
+    def new_unmarshal_factory_context(self) -> UnmarshalFactoryContext:
+        return UnmarshalFactoryContext(
+            configs=self.config_registry(),
+            unmarshaler_factory=self.unmarshaler_factory(),
+        )
+
+    ##
 
-    def new_marshal_context(self, **kwargs: ta.Any) -> MarshalContext:
+    def new_marshal_context(self) -> MarshalContext:
         return MarshalContext(
-            config_registry=self.config_registry(),
-            factory=self.marshaler_factory(),
-            **kwargs,
+            configs=self.config_registry(),
+            marshal_factory_context=self.new_marshal_factory_context(),
         )
 
-    def new_unmarshal_context(self, **kwargs: ta.Any) -> UnmarshalContext:
+    def new_unmarshal_context(self) -> UnmarshalContext:
         return UnmarshalContext(
-            config_registry=self.config_registry(),
-            factory=self.unmarshaler_factory(),
-            **kwargs,
+            configs=self.config_registry(),
+            unmarshal_factory_context=self.new_unmarshal_factory_context(),
         )
 
     #
@@ -98,3 +110,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,15 @@ 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 MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 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 +30,9 @@ DEFAULT_ITERABLE_CONCRETE_TYPES: dict[type[collections.abc.Iterable], type[colle
 }
 
 
+#
+
+
 @dc.dataclass(frozen=True)
 class IterableMarshaler(Marshaler):
     e: Marshaler
@@ -37,15 +41,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: MarshalFactoryContext, 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_marshaler(check.single(rty.args)))
+
+    @MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_concrete(self, ctx: MarshalFactoryContext, 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_marshaler(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 +67,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: UnmarshalFactoryContext, 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_unmarshaler(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: UnmarshalFactoryContext, 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_unmarshaler(ta.Any))

omlish/marshal/composite/literals.py

@@ -1,15 +1,21 @@
+"""
+TODO:
+ - squash literal unions - typing machinery doesn't
+"""
 import dataclasses as dc
 import typing as ta
 
 from ... import check
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 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
 
 
 ##
@@ -24,14 +30,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)
-
-    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: MarshalFactoryContext, 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_marshaler(ety), frozenset(rty.args))
 
 
 @dc.dataclass(frozen=True)
@@ -43,11 +47,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)
-
-    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: UnmarshalFactoryContext, 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_unmarshaler(ety), frozenset(rty.args))