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

omlish/marshal/composite/literals.py

@@ -8,12 +8,14 @@ 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
 
 
 ##
@@ -28,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) 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: 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)
@@ -47,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) 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: 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))

omlish/marshal/composite/mappings.py

@@ -4,14 +4,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
 
 
 ##
@@ -23,6 +24,9 @@ DEFAULT_MAPPING_CONCRETE_TYPES: dict[type[collections.abc.Mapping], type[collect
 }
 
 
+#
+
+
 @dc.dataclass(frozen=True)
 class MappingMarshaler(Marshaler):
     ke: Marshaler
@@ -35,16 +39,22 @@ class MappingMarshaler(Marshaler):
         }
 
 
-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))
+class MappingMarshalerFactory(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.Mapping)):
+            return None
+        kt, vt = rty.args
+        return lambda: MappingMarshaler(ctx.make_marshaler(kt), ctx.make_marshaler(vt))
+
+    @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.Mapping)):
+            return None
+        return lambda: MappingMarshaler(a := ctx.make_marshaler(ta.Any), a)
 
-    @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)
@@ -60,14 +70,17 @@ class MappingUnmarshaler(Unmarshaler):
         return self.ctor(dct)
 
 
-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)
-        cty = DEFAULT_MAPPING_CONCRETE_TYPES.get(gty.cls, gty.cls)  # noqa
-        kt, vt = gty.args
-        return MappingUnmarshaler(cty, 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)
+class MappingUnmarshalerFactory(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.Mapping)):
+            return None
+        cty = DEFAULT_MAPPING_CONCRETE_TYPES.get(rty.cls, rty.cls)  # noqa
+        kt, vt = rty.args
+        return lambda: MappingUnmarshaler(cty, ctx.make_unmarshaler(kt), ctx.make_unmarshaler(vt))
+
+    @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.Mapping)):
+            return None
+        return lambda: MappingUnmarshaler(check.isinstance(rty, type), a := ctx.make_unmarshaler(ta.Any), a)

omlish/marshal/composite/maybes.py

@@ -8,14 +8,15 @@ 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 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
 
 
 ##
@@ -33,15 +34,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: MarshalFactoryContext, 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_marshaler(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: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, lang.Maybe)):
+            return None
+        return lambda: MaybeMarshaler(ctx.make_marshaler(ta.Any))
+
+
+#
 
 
 @dc.dataclass(frozen=True)
@@ -55,12 +62,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: UnmarshalFactoryContext, 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_unmarshaler(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: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, lang.Maybe)):
+            return None
+        return lambda: MaybeUnmarshaler(ctx.make_unmarshaler(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.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 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: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not isinstance(rty, rfl.NewType):
+            return None
+        return lambda: ctx.make_marshaler(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: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not isinstance(rty, rfl.NewType):
+            return None
+        return lambda: ctx.make_unmarshaler(check.isinstance(rty, rfl.NewType).ty)

omlish/marshal/composite/optionals.py

@@ -4,12 +4,14 @@ 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
 
 
 ##
@@ -25,12 +27,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: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, rfl.Union) and rty.is_optional):
+            return None
+        return lambda: OptionalMarshaler(ctx.make_marshaler(check.isinstance(rty, rfl.Union).without_none()))
 
 
 @dc.dataclass(frozen=True)
@@ -43,9 +44,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: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Union) and rty.is_optional):
+            return None
+        return lambda: OptionalUnmarshaler(ctx.make_unmarshaler(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.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 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: MarshalFactoryContext, 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_marshaler(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: UnmarshalFactoryContext, 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_unmarshaler(check.single(rty.args)))

omlish/marshal/composite/unions/literals.py

@@ -0,0 +1,93 @@
+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 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
+
+
+##
+
+
+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: MarshalFactoryContext, 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_marshaler(ds.lit), ctx.make_marshaler(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: UnmarshalFactoryContext, 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_unmarshaler(ds.lit), ctx.make_unmarshaler(ds.non_lit))

omlish/marshal/composite/unions/primitives.py

@@ -0,0 +1,103 @@
+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 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
+
+
+##
+
+
+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: MarshalFactoryContext, 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_marshaler(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: UnmarshalFactoryContext, 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_unmarshaler(check.single(ds.non_prim)) if ds.non_prim else None,
+        )