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

omlish/marshal/composite/maybes.py

@@ -8,14 +8,13 @@ import typing as ta
 from ... import check
 from ... import lang
 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
 
 
 ##
@@ -33,15 +32,21 @@ class MaybeMarshaler(Marshaler):
             return []
 
 
-class MaybeMarshalerFactory(MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is lang.Maybe)
-    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        return MaybeMarshaler(ctx.make(check.single(gty.args)))
+class MaybeMarshalerFactory(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 rty.cls is lang.Maybe):
+            return None
+        return lambda: MaybeMarshaler(ctx.make(check.single(rty.args)))
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, lang.Maybe))
-    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return MaybeMarshaler(ctx.make(ta.Any))
+    @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, lang.Maybe)):
+            return None
+        return lambda: MaybeMarshaler(ctx.make(ta.Any))
+
+
+#
 
 
 @dc.dataclass(frozen=True)
@@ -55,12 +60,15 @@ class MaybeUnmarshaler(Unmarshaler):
             return lang.empty()
 
 
-class MaybeUnmarshalerFactory(UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is lang.Maybe)
-    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        gty = check.isinstance(rty, rfl.Generic)
-        return MaybeUnmarshaler(ctx.make(check.single(gty.args)))
+class MaybeUnmarshalerFactory(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 rty.cls is lang.Maybe):
+            return None
+        return lambda: MaybeUnmarshaler(ctx.make(check.single(rty.args)))
 
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, lang.Maybe))
-    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return MaybeUnmarshaler(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, lang.Maybe)):
+            return None
+        return lambda: MaybeUnmarshaler(ctx.make(ta.Any))

omlish/marshal/composite/newtypes.py

@@ -1,27 +1,27 @@
+import typing as ta
+
 from ... import check
 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 ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 
 
 ##
 
 
-class NewtypeMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.NewType)
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return ctx.make(check.isinstance(rty, rfl.NewType).ty)
-
+class NewtypeMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not isinstance(rty, rfl.NewType):
+            return None
+        return lambda: ctx.make(check.isinstance(rty, rfl.NewType).ty)
 
-class NewtypeUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.NewType)
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return ctx.make(check.isinstance(rty, rfl.NewType).ty)
+class NewtypeUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not isinstance(rty, rfl.NewType):
+            return None
+        return lambda: ctx.make(check.isinstance(rty, rfl.NewType).ty)

omlish/marshal/composite/optionals.py

@@ -6,10 +6,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
 
 
 ##
@@ -25,12 +25,11 @@ class OptionalMarshaler(Marshaler):
         return self.e.marshal(ctx, o)
 
 
-class OptionalMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Union) and rty.is_optional
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return OptionalMarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))
+class OptionalMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Union) and rty.is_optional):
+            return None
+        return lambda: OptionalMarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))
 
 
 @dc.dataclass(frozen=True)
@@ -43,9 +42,8 @@ class OptionalUnmarshaler(Unmarshaler):
         return self.e.unmarshal(ctx, v)
 
 
-class OptionalUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Union) and rty.is_optional
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return OptionalUnmarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))
+class OptionalUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Union) and rty.is_optional):
+            return None
+        return lambda: OptionalUnmarshaler(ctx.make(check.isinstance(rty, rfl.Union).without_none()))

omlish/marshal/composite/special.py

@@ -1,15 +1,15 @@
 import collections.abc
+import typing as ta
 
 from ... import check
 from ... import lang
 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 MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.match import MarshalerFactoryMatchClass
-from ..factories.match import UnmarshalerFactoryMatchClass
+from ..base.types import UnmarshalerFactory
 from .iterables import DEFAULT_ITERABLE_CONCRETE_TYPES
 from .iterables import IterableMarshaler
 from .iterables import IterableUnmarshaler
@@ -18,16 +18,16 @@ from .iterables import IterableUnmarshaler
 ##
 
 
-class SequenceNotStrMarshalerFactory(MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr)
-    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        gty = check.isinstance(rty, rfl.Protocol)
-        return IterableMarshaler(ctx.make(check.single(gty.args)))
+class SequenceNotStrMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr):
+            return None
+        return lambda: IterableMarshaler(ctx.make(check.single(rty.args)))
 
 
-class SequenceNotStrUnmarshalerFactory(UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr)
-    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        gty = check.isinstance(rty, rfl.Protocol)
+class SequenceNotStrUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr):
+            return None
         cty = DEFAULT_ITERABLE_CONCRETE_TYPES[collections.abc.Sequence]  # type: ignore[type-abstract]
-        return IterableUnmarshaler(cty, ctx.make(check.single(gty.args)))
+        return lambda: IterableUnmarshaler(cty, ctx.make(check.single(rty.args)))

omlish/marshal/composite/unions/literals.py

@@ -0,0 +1,91 @@
+import typing as ta
+
+from .... import check
+from .... import collections as col
+from .... import dataclasses as dc
+from .... import lang
+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
+
+
+##
+
+
+LITERAL_UNION_TYPES: tuple[type, ...] = (
+    int,
+    str,
+)
+
+
+class DestructuredLiteralUnionType(ta.NamedTuple):
+    v_ty: type
+    lit: rfl.Literal
+    non_lit: rfl.Type
+
+
+def _destructure_literal_union_type(rty: rfl.Type) -> DestructuredLiteralUnionType | None:
+    if not isinstance(rty, rfl.Union):
+        return None
+    lits, non_lits = col.partition(rty.args, lang.isinstance_of(rfl.Literal))  # noqa
+    if len(lits) != 1 or len(non_lits) != 1:
+        return None
+    lit = check.isinstance(check.single(lits), rfl.Literal)
+    v_tys = set(map(type, lit.args))
+    if len(v_tys) != 1:
+        return None
+    [v_ty] = v_tys
+    if v_ty in rty.args or v_ty not in LITERAL_UNION_TYPES:
+        return None
+    return DestructuredLiteralUnionType(v_ty, lit, check.single(non_lits))
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnionMarshaler(Marshaler):
+    v_ty: type
+    l: Marshaler
+    x: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        if isinstance(o, self.v_ty):
+            return self.l.marshal(ctx, o)
+        else:
+            return self.x.marshal(ctx, o)
+
+
+class LiteralUnionMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if (ds := _destructure_literal_union_type(rty)) is None:
+            return None
+        return lambda: LiteralUnionMarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnionUnmarshaler(Unmarshaler):
+    v_ty: type
+    l: Unmarshaler
+    x: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        if isinstance(v, self.v_ty):
+            return self.l.unmarshal(ctx, v)  # type: ignore[arg-type]
+        else:
+            return self.x.unmarshal(ctx, v)
+
+
+class LiteralUnionUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if (ds := _destructure_literal_union_type(rty)) is None:
+            return None
+        return lambda: LiteralUnionUnmarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))

omlish/marshal/composite/unions/primitives.py

@@ -0,0 +1,101 @@
+import typing as ta
+
+from .... import check
+from .... import collections as col
+from .... import dataclasses as dc
+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
+
+
+##
+
+
+PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
+    float,
+    int,
+    str,
+    bool,
+)
+
+
+class DestructuredPrimitiveUnionType(ta.NamedTuple):
+    prim: ta.Sequence[type]
+    non_prim: ta.Sequence[rfl.Type]
+
+
+def _destructure_primitive_union_type(
+        rty: rfl.Type,
+        prim_tys: ta.Container[type] = PRIMITIVE_UNION_TYPES,
+) -> DestructuredPrimitiveUnionType | None:
+    if not isinstance(rty, rfl.Union):
+        return None
+
+    pr = col.partition(rty.args, lambda a: isinstance(a, type) and a in prim_tys)
+    if not pr.t or len(pr.f) > 1:
+        return None
+
+    return DestructuredPrimitiveUnionType(*pr)  # type: ignore[arg-type]
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshaler(Marshaler):
+    tys: ta.Sequence[type]
+    x: Marshaler | None = None
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        if type(o) not in self.tys:
+            if self.x is not None:
+                return self.x.marshal(ctx, o)
+            raise TypeError(o)
+        return o
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshalerFactory(MarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if (ds := _destructure_primitive_union_type(rty, self.tys)) is None:
+            return None
+        return lambda: PrimitiveUnionMarshaler(
+            ds.prim,
+            ctx.make(check.single(ds.non_prim)) if ds.non_prim else None,
+        )
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshaler(Unmarshaler):
+    tys: ta.Sequence[type]
+    x: Unmarshaler | None = None
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        if type(v) not in self.tys:
+            if self.x is not None:
+                return self.x.unmarshal(ctx, v)
+            raise TypeError(v)
+        return v
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if (ds := _destructure_primitive_union_type(rty, self.tys)) is None:
+            return None
+        return lambda: PrimitiveUnionUnmarshaler(
+            ds.prim,
+            ctx.make(check.single(ds.non_prim)) if ds.non_prim else None,
+        )

omlish/marshal/factories/invalidate.py

@@ -2,44 +2,39 @@ import threading
 import typing as ta
 
 from ... import reflect as rfl
-from ...funcs import match as mfs
-from ..base.contexts import BaseContext
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
 from ..base.types import MarshalerFactory
-from ..base.types import MarshalerMaker
 from ..base.types import Unmarshaler
 from ..base.types import UnmarshalerFactory
-from ..base.types import UnmarshalerMaker
 
 
-R = ta.TypeVar('R')
-ContextT = ta.TypeVar('ContextT', bound=BaseContext)
+FactoryT = ta.TypeVar('FactoryT', bound=MarshalerFactory | UnmarshalerFactory)
 
 
 ##
 
 
-class _InvalidatableFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
+class _InvalidatableFactory(ta.Generic[FactoryT]):
     def __init__(
             self,
-            fn: ta.Callable[[], mfs.MatchFn[[ContextT, rfl.Type], R]],
+            fac_fac: ta.Callable,
             check_fn: ta.Callable[[], bool] | None = None,
     ) -> None:
         super().__init__()
 
-        self._fn = fn
+        self._fac_fac = fac_fac
         self._check_fn: ta.Callable[[], bool] | None = check_fn
 
         self._lock = threading.RLock()
 
     #
 
-    _f_: mfs.MatchFn[[ContextT, rfl.Type], R] | None = None
+    __fac: FactoryT | None = None
 
     def _invalidate(self) -> None:
-        self._f_ = None
+        self.__fac = None
 
     def invalidate(self) -> None:
         with self._lock:
@@ -52,67 +47,22 @@ class _InvalidatableFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
                     if self._check_fn():
                         self._invalidate()
 
-    def _f(self) -> mfs.MatchFn[[ContextT, rfl.Type], R]:
+    def _fac(self) -> FactoryT:
         self._maybe_invalidate()
 
-        if (f := self._f_) is None:
+        if (f := self.__fac) is None:
             with self._lock:
-                if (f := self._f_) is None:
-                    f = self._f_ = self._fn()
+                if (f := self.__fac) is None:
+                    f = self.__fac = self._fac_fac()
 
         return f
 
-    #
-
-    def guard(self, ctx: ContextT, rty: rfl.Type) -> bool:
-        return self._f().guard(ctx, rty)
-
-    def fn(self, ctx: ContextT, rty: rfl.Type) -> R:
-        return self._f()(ctx, rty)
-
-
-##
-
-
-class InvalidatableMarshalerFactory(MarshalerFactory):
-    def __init__(
-            self,
-            fn: ta.Callable[[], MarshalerFactory],
-            check_fn: ta.Callable[[], bool] | None = None,
-    ) -> None:
-        super().__init__()
 
-        self._fn = fn
-        self._u: _InvalidatableFactory[MarshalContext, Marshaler] = _InvalidatableFactory(
-            lambda: fn().make_marshaler,
-            check_fn,
-        )
+class InvalidatableMarshalerFactory(_InvalidatableFactory[MarshalerFactory], MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        return self._fac().make_marshaler(ctx, rty)
 
-    def invalidate(self) -> None:
-        self._u.invalidate()
-
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._u
-
-
-class InvalidatableUnmarshalerFactory(UnmarshalerFactory):
-    def __init__(
-            self,
-            fn: ta.Callable[[], UnmarshalerFactory],
-            check_fn: ta.Callable[[], bool] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._fn = fn
-        self._u: _InvalidatableFactory[UnmarshalContext, Unmarshaler] = _InvalidatableFactory(
-            lambda: fn().make_unmarshaler,
-            check_fn,
-        )
-
-    def invalidate(self) -> None:
-        self._u.invalidate()
 
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self._u
+class InvalidatableUnmarshalerFactory(_InvalidatableFactory[UnmarshalerFactory], UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        return self._fac().make_unmarshaler(ctx, rty)

omlish/marshal/factories/method.py

@@ -0,0 +1,28 @@
+import typing as ta
+
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import guard as gfs
+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
+
+
+##
+
+
+class MarshalerFactoryMethodClass(MarshalerFactory, lang.Abstract):
+    @ta.final
+    @gfs.method(instance_cache=True)
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        raise NotImplementedError
+
+
+class UnmarshalerFactoryMethodClass(UnmarshalerFactory, lang.Abstract):
+    @ta.final
+    @gfs.method(instance_cache=True)
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        raise NotImplementedError

omlish/marshal/factories/moduleimport/factories.py

@@ -11,41 +11,37 @@ import threading
 import typing as ta
 
 from .... import reflect as rfl
-from ....funcs import match as mfs
 from ...base.contexts import BaseContext
 from ...base.contexts import MarshalContext
 from ...base.contexts import UnmarshalContext
 from ...base.types import Marshaler
 from ...base.types import MarshalerFactory
-from ...base.types import MarshalerMaker
 from ...base.types import Unmarshaler
 from ...base.types import UnmarshalerFactory
-from ...base.types import UnmarshalerMaker
 from .configs import ModuleImport
 
 
-R = ta.TypeVar('R')
-ContextT = ta.TypeVar('ContextT', bound=BaseContext)
+FactoryT = ta.TypeVar('FactoryT', bound=MarshalerFactory | UnmarshalerFactory)
 
 
 ##
 
 
-class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
+class _ModuleImportingFactory(ta.Generic[FactoryT]):
     def __init__(
             self,
-            f: mfs.MatchFn[[ContextT, rfl.Type], R],
+            fac: FactoryT,
             callback: ta.Callable[[], None] | None = None,
     ) -> None:
         super().__init__()
 
-        self._f = f
+        self._fac = fac
         self._callback = callback
 
         self._lock = threading.RLock()
         self._last_mis: ta.Any = None
 
-    def _do_import(self, ctx: ContextT, mis: ta.Sequence[ModuleImport]) -> None:
+    def _do_import(self, ctx: BaseContext, mis: ta.Sequence[ModuleImport]) -> None:
         c = 0
         for mi in mis:
             if mi.import_if_necessary():
@@ -55,58 +51,21 @@ class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
             if self._callback is not None:
                 self._callback()
 
-    def _import_if_necessary(self, ctx: ContextT) -> None:
+    def _import_if_necessary(self, ctx: BaseContext) -> None:
         if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
             with self._lock:
                 if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
                     self._do_import(ctx, mis)
                     self._last_mis = mis
 
-    def guard(self, ctx: ContextT, rty: rfl.Type) -> bool:
-        self._import_if_necessary(ctx)
-        return self._f.guard(ctx, rty)
 
-    def fn(self, ctx: ContextT, rty: rfl.Type) -> R:
+class ModuleImportingMarshalerFactory(_ModuleImportingFactory[MarshalerFactory], MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
         self._import_if_necessary(ctx)
-        return self._f(ctx, rty)
-
-
-##
-
-
-class ModuleImportingMarshalerFactory(MarshalerFactory):
-    def __init__(
-            self,
-            f: MarshalerFactory,
-            callback: ta.Callable[[], None] | None = None,
-    ) -> None:
-        super().__init__()
+        return self._fac.make_marshaler(ctx, rty)
 
-        self._f = f
-        self._tcf: _ModuleImportingFactory[MarshalContext, Marshaler] = _ModuleImportingFactory(
-            f.make_marshaler,
-            callback,
-        )
 
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self._tcf
-
-
-class ModuleImportingUnmarshalerFactory(UnmarshalerFactory):
-    def __init__(
-            self,
-            f: UnmarshalerFactory,
-            callback: ta.Callable[[], None] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._f = f
-        self._tcf: _ModuleImportingFactory[UnmarshalContext, Unmarshaler] = _ModuleImportingFactory(
-            f.make_unmarshaler,
-            callback,
-        )
-
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self._tcf
+class ModuleImportingUnmarshalerFactory(_ModuleImportingFactory[UnmarshalerFactory], UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        self._import_if_necessary(ctx)
+        return self._fac.make_unmarshaler(ctx, rty)