omlish 0.0.0.dev6__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

omlish/marshal/factories.py

@@ -1,86 +1,105 @@
-import abc
 import dataclasses as dc
-import enum
 import threading
 import typing as ta
 
+from .. import check
+from .. import matchfns as mfs
 from .. import reflect as rfl
 
 
 R = ta.TypeVar('R')
 C = ta.TypeVar('C')
-A = ta.TypeVar('A')
-
-
-##
-
-
-class Factory(abc.ABC, ta.Generic[R, C, A]):
-    @abc.abstractmethod
-    def __call__(self, ctx: C, arg: A) -> R | None:
-        raise NotImplementedError
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class FuncFactory(ta.Generic[R, C, A]):
-    fn: ta.Callable[[C, A], R | None]
-
-    def __call__(self, ctx: C, arg: A) -> R | None:
-        return self.fn(ctx, arg)
-
-
-##
+class TypeMapFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
 
+    def __post_init__(self) -> None:
+        for k in self.m:
+            if not isinstance(k, rfl.TYPES):
+                raise TypeError(k)
 
-@dc.dataclass(frozen=True)
-class TypeMapFactory(Factory[R, C, rfl.Type]):
-    m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
+        return rty in self.m
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
-        return self.m.get(rty)
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            return self.m[rty]
+        except KeyError:
+            raise mfs.MatchGuardError(ctx, rty)  # noqa
 
 
 ##
 
 
-class TypeCacheFactory(Factory[R, C, rfl.Type]):
-    def __init__(self, f: Factory[R, C, rfl.Type]) -> None:
+class TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    def __init__(self, f: mfs.MatchFn[[C, rfl.Type], R]) -> None:
         super().__init__()
         self._f = f
         self._dct: dict[rfl.Type, R | None] = {}
         self._mtx = threading.RLock()
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
-        try:
-            return self._dct[rty]
-        except KeyError:
-            pass
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
         with self._mtx:
             try:
-                return self._dct[rty]
+                e = self._dct[rty]
             except KeyError:
-                ret = self._dct[rty] = self._f(ctx, rty)
-                return ret
+                if self._f.guard(ctx, rty):
+                    return True
+                else:
+                    self._dct[rty] = None
+                    return False
+            else:
+                return e is not None
+
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
+        with self._mtx:
+            try:
+                e = self._dct[rty]
+            except KeyError:
+                try:
+                    ret = self._f(ctx, rty)
+                except mfs.MatchGuardError:
+                    self._dct[rty] = None
+                    raise
+                else:
+                    self._dct[rty] = ret
+                    return ret
+            else:
+                if e is None:
+                    raise mfs.MatchGuardError(ctx, rty)
+                else:
+                    return e
 
 
 ##
 
 
-class RecursiveTypeFactory(Factory[R, C, rfl.Type]):
+class RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
     def __init__(
             self,
-            f: Factory[R, C, rfl.Type],
-            prx: ta.Callable[[], tuple[R | None, ta.Callable[[R | None], None]]],
+            f: mfs.MatchFn[[C, rfl.Type], R],
+            prx: ta.Callable[[], tuple[R, ta.Callable[[R], None]]],
     ) -> None:
         super().__init__()
         self._f = f
         self._prx = prx
-        self._dct: dict[rfl.Type, R | None] = {}
+        self._dct: dict[rfl.Type, R] = {}
+
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        check.isinstance(rty, rfl.TYPES)
+        return self._f.guard(ctx, rty)
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        check.isinstance(rty, rfl.TYPES)
         try:
             return self._dct[rty]
         except KeyError:
@@ -93,37 +112,3 @@ class RecursiveTypeFactory(Factory[R, C, rfl.Type]):
             return r
         finally:
             del self._dct[rty]
-
-
-##
-
-
-class CompositeFactory(Factory[R, C, A]):
-    class Strategy(enum.Enum):
-        FIRST = enum.auto()
-        ONE = enum.auto()
-
-    def __init__(self, *fs: Factory[R, C, A], strategy: Strategy = Strategy.FIRST) -> None:
-        super().__init__()
-        self._fs = fs
-        self._st = strategy
-
-    def __call__(self, ctx: C, arg: A) -> R | None:
-        w: list[R] = []
-        for c in self._fs:
-            if (r := c(ctx, arg)) is None:
-                continue
-            if self._st is CompositeFactory.Strategy.FIRST:
-                return r
-            w.append(r)
-
-        if not w:
-            return None
-
-        if self._st is CompositeFactory.Strategy.ONE:
-            if len(w) == 1:
-                return w[0]
-
-            raise TypeError(f'multiple implementations: {arg} {w}')
-
-        raise TypeError(f'unknown composite strategy: {self._st}')

omlish/marshal/forbidden.py

@@ -0,0 +1,35 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import matchfns as mfs
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .exceptions import ForbiddenTypeError
+
+
+C = ta.TypeVar('C')
+R = ta.TypeVar('R')
+
+
+@dc.dataclass(frozen=True)
+class ForbiddenTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
+    rtys: ta.AbstractSet[rfl.Type]
+
+    def guard(self, ctx: C, rty: rfl.Type) -> bool:
+        return rty in self.rtys
+
+    def fn(self, ctx: C, rty: rfl.Type) -> R:
+        raise ForbiddenTypeError(rty)
+
+
+@dc.dataclass(frozen=True)
+class ForbiddenTypeMarshalerFactory(ForbiddenTypeFactory[MarshalContext, Marshaler]):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class ForbiddenTypeUnmarshalerFactory(ForbiddenTypeFactory[UnmarshalContext, Unmarshaler]):
+    pass

omlish/marshal/global_.py

@@ -1,7 +1,10 @@
 import typing as ta
 
+from .. import lang
 from .base import MarshalContext
+from .base import MarshalerFactory
 from .base import UnmarshalContext
+from .base import UnmarshalerFactory
 from .registries import Registry
 from .standard import new_standard_marshaler_factory
 from .standard import new_standard_unmarshaler_factory
@@ -20,20 +23,24 @@ GLOBAL_REGISTRY = Registry()
 ##
 
 
-GLOBAL_MARSHALER_FACTORY = new_standard_marshaler_factory()
+@lang.cached_function(lock=True)
+def global_marshaler_factory() -> MarshalerFactory:
+    return new_standard_marshaler_factory()
 
 
 def marshal(obj: ta.Any, ty: type | None = None, **kwargs: ta.Any) -> Value:
-    mc = MarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_MARSHALER_FACTORY, **kwargs)
+    mc = MarshalContext(GLOBAL_REGISTRY, factory=global_marshaler_factory(), **kwargs)
     return mc.make(ty if ty is not None else type(obj)).marshal(mc, obj)
 
 
 ##
 
 
-GLOBAL_UNMARSHALER_FACTORY = new_standard_unmarshaler_factory()
+@lang.cached_function(lock=True)
+def global_unmarshaler_factory() -> UnmarshalerFactory:
+    return new_standard_unmarshaler_factory()
 
 
 def unmarshal(v: Value, ty: type[T], **kwargs: ta.Any) -> T:
-    uc = UnmarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_UNMARSHALER_FACTORY, **kwargs)
+    uc = UnmarshalContext(GLOBAL_REGISTRY, factory=global_unmarshaler_factory(), **kwargs)
     return uc.make(ty).unmarshal(uc, v)

omlish/marshal/iterables.py

@@ -4,13 +4,14 @@ import functools
 import typing as ta
 
 from .. import check
+from .. import matchfns as mfs
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import MarshalerFactoryMatchClass
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
+from .base import UnmarshalerFactoryMatchClass
 from .values import Value
 
 
@@ -22,17 +23,15 @@ class IterableMarshaler(Marshaler):
         return list(map(functools.partial(self.e.marshal, ctx), o))
 
 
-class IterableMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
-            if (e := ctx.make(check.single(rty.args))) is None:
-                return None  # type: ignore
-            return IterableMarshaler(e)
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Iterable):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return IterableMarshaler(e)
-        return None
+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)))
+
+    @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)
@@ -44,14 +43,12 @@ class IterableUnmarshaler(Unmarshaler):
         return self.ctor(map(functools.partial(self.e.unmarshal, ctx), check.isinstance(v, collections.abc.Iterable)))
 
 
-class IterableUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
-            if (e := ctx.make(check.single(rty.args))) is None:
-                return None  # type: ignore
-            return IterableUnmarshaler(rty.cls, e)  # noqa
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Iterable):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return IterableUnmarshaler(rty, e)  # noqa
-        return None
+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)
+        return IterableUnmarshaler(gty.cls, ctx.make(check.single(gty.args)))
+
+    @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))

omlish/marshal/mappings.py

@@ -3,13 +3,14 @@ import dataclasses as dc
 import typing as ta
 
 from .. import check
+from .. import matchfns as mfs
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import MarshalerFactoryMatchClass
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
+from .base import UnmarshalerFactoryMatchClass
 from .values import Value
 
 
@@ -25,18 +26,16 @@ class MappingMarshaler(Marshaler):
         }
 
 
-class MappingMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
-            kt, vt = rty.args
-            if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
-                return None  # type: ignore
-            return MappingMarshaler(ke, ve)
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Mapping):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return MappingMarshaler(e, e)
-        return None
+class MappingMarshalerFactory(MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping))
+    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        gty = check.isinstance(rty, rfl.Generic)
+        kt, vt = gty.args
+        return MappingMarshaler(ctx.make(kt), ctx.make(vt))
+
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Mapping))
+    def _build_concrete(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return MappingMarshaler(a := ctx.make(ta.Any), a)
 
 
 @dc.dataclass(frozen=True)
@@ -52,15 +51,13 @@ class MappingUnmarshaler(Unmarshaler):
         return self.ctor(dct)
 
 
-class MappingUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
-            kt, vt = rty.args
-            if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
-                return None  # type: ignore
-            return MappingUnmarshaler(rty.cls, ke, ve)
-        if isinstance(rty, type) and issubclass(rty, collections.abc.Mapping):
-            if (e := ctx.make(ta.Any)) is None:
-                return None  # type: ignore
-            return MappingUnmarshaler(rty, e, e)
-        return None
+class MappingUnmarshalerFactory(UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping))
+    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        gty = check.isinstance(rty, rfl.Generic)
+        kt, vt = gty.args
+        return MappingUnmarshaler(gty.cls, ctx.make(kt), ctx.make(vt))
+
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, type) and issubclass(rty, collections.abc.Mapping))
+    def _build_concrete(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        return MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make(ta.Any), a)

omlish/marshal/numbers.py

@@ -0,0 +1,51 @@
+import decimal
+import fractions
+import typing as ta
+
+from .. import check
+from .base import MarshalContext
+from .base import Marshaler
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .values import Value
+
+
+class ComplexMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: complex) -> Value:
+        return [o.real, o.imag]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        real, imag = check.isinstance(v, list)
+        return complex(real, imag)  # type: ignore
+
+
+class DecimalMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: decimal.Decimal) -> Value:
+        return str(o)
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return decimal.Decimal(check.isinstance(v, str))
+
+
+class FractionMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: fractions.Fraction) -> Value:
+        return [o.numerator, o.denominator]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        num, denom = check.isinstance(v, list)
+        return fractions.Fraction(num, denom)  # type: ignore
+
+
+NUMBERS_MARSHALER_FACTORY = TypeMapMarshalerFactory({
+    complex: ComplexMarshalerUnmarshaler(),
+    decimal.Decimal: DecimalMarshalerUnmarshaler(),
+    fractions.Fraction: FractionMarshalerUnmarshaler(),
+})
+
+NUMBERS_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({
+    complex: ComplexMarshalerUnmarshaler(),
+    decimal.Decimal: DecimalMarshalerUnmarshaler(),
+    fractions.Fraction: FractionMarshalerUnmarshaler(),
+})

omlish/marshal/optionals.py

@@ -1,6 +1,7 @@
 import dataclasses as dc
 import typing as ta
 
+from .. import check
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
@@ -22,12 +23,11 @@ class OptionalMarshaler(Marshaler):
 
 
 class OptionalMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, rfl.Union) and rty.is_optional:
-            if (e := ctx.make(rty.without_none())) is None:
-                return None  # type: ignore
-            return OptionalMarshaler(e)
-        return None
+    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()))
 
 
 @dc.dataclass(frozen=True)
@@ -41,9 +41,8 @@ class OptionalUnmarshaler(Unmarshaler):
 
 
 class OptionalUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, rfl.Union) and rty.is_optional:
-            if (e := ctx.make(rty.without_none())) is None:
-                return None  # type: ignore
-            return OptionalUnmarshaler(e)
-        return None
+    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()))

omlish/marshal/polymorphism.py

@@ -19,12 +19,29 @@ from .base import Unmarshaler
 from .base import UnmarshalerFactory
 from .naming import Naming
 from .naming import translate_name
+from .registries import RegistryItem
 from .values import Value
 
 
 ##
 
 
+class TypeTagging(RegistryItem, lang.Abstract, lang.Sealed):
+    pass
+
+
+class WrapperTypeTagging(TypeTagging, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class FieldTypeTagging(TypeTagging, lang.Final):
+    field: str
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class Impl:
     ty: type
@@ -33,7 +50,11 @@ class Impl:
 
 
 class Polymorphism:
-    def __init__(self, ty: type, impls: ta.Iterable[Impl]) -> None:
+    def __init__(
+            self,
+            ty: type,
+            impls: ta.Iterable[Impl],
+    ) -> None:
         super().__init__()
         self._ty = ty
         self._impls = list(impls)
@@ -72,7 +93,11 @@ class Polymorphism:
         return self._by_tag
 
 
-def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> Polymorphism:
+def polymorphism_from_subclasses(
+        ty: type,
+        *,
+        naming: Naming | None = None,
+) -> Polymorphism:
     dct: dict[str, Impl] = {}
     seen: set[type] = set()
     todo: list[type] = [ty]
@@ -97,7 +122,7 @@ def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> P
 
 
 @dc.dataclass(frozen=True)
-class DictKeyPolymorphismMarshaler(Marshaler):
+class WrapperPolymorphismMarshaler(Marshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
 
     def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
@@ -105,24 +130,43 @@ class DictKeyPolymorphismMarshaler(Marshaler):
         return {tag: m.marshal(ctx, o)}
 
 
+@dc.dataclass(frozen=True)
+class FieldPolymorphismMarshaler(Marshaler):
+    m: ta.Mapping[type, tuple[str, Marshaler]]
+    tf: str
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        tag, m = self.m[type(o)]
+        return {self.tf: tag, **m.marshal(ctx, o)}  # type: ignore
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
+    tt: TypeTagging = WrapperTypeTagging()
 
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if rty is self.p.ty:
-            return DictKeyPolymorphismMarshaler({
-                i.ty: (i.tag, ctx.make(i.ty))
-                for i in self.p.impls
-            })
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        check.is_(rty, self.p.ty)
+        m = {
+            i.ty: (i.tag, ctx.make(i.ty))
+            for i in self.p.impls
+        }
+        if isinstance(self.tt, WrapperTypeTagging):
+            return WrapperPolymorphismMarshaler(m)
+        elif isinstance(self.tt, FieldTypeTagging):
+            return FieldPolymorphismMarshaler(m, self.tt.field)
+        else:
+            raise TypeError(self.tt)
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class DictKeyPolymorphismUnmarshaler(Unmarshaler):
+class WrapperPolymorphismUnmarshaler(Unmarshaler):
     m: ta.Mapping[str, Unmarshaler]
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
@@ -132,16 +176,37 @@ class DictKeyPolymorphismUnmarshaler(Unmarshaler):
         return u.unmarshal(ctx, iv)  # type: ignore
 
 
+@dc.dataclass(frozen=True)
+class FieldPolymorphismUnmarshaler(Unmarshaler):
+    m: ta.Mapping[str, Unmarshaler]
+    tf: str
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        ma = dict(check.isinstance(v, collections.abc.Mapping))
+        tag = ma.pop(self.tf)  # type: ignore
+        u = self.m[tag]  # type: ignore
+        return u.unmarshal(ctx, ma)
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
-
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if rty is self.p.ty:
-            return DictKeyPolymorphismUnmarshaler({
-                t: u
-                for i in self.p.impls
-                for u in [ctx.make(i.ty)]
-                for t in [i.tag, *i.alts]
-            })
-        return None
+    tt: TypeTagging = WrapperTypeTagging()
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        check.is_(rty, self.p.ty)
+        m = {
+            t: u
+            for i in self.p.impls
+            for u in [ctx.make(i.ty)]
+            for t in [i.tag, *i.alts]
+        }
+        if isinstance(self.tt, WrapperTypeTagging):
+            return WrapperPolymorphismUnmarshaler(m)
+        elif isinstance(self.tt, FieldTypeTagging):
+            return FieldPolymorphismUnmarshaler(m, self.tt.field)
+        else:
+            raise TypeError(self.tt)