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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev453'
-__revision__ = '66cf981e193780bd726e2a5ea06dd1ac590f7298'
+__version__ = '0.0.0.dev455'
+__revision__ = '83eb94a310c0880350d3f2b4440d1673f4d9402d'
 
 
 #

omlish/collections/identity.py

@@ -105,6 +105,7 @@ class IdentityWeakKeyDictionary(ta.MutableMapping[K, V]):
 
     TODO:
      - audit for freethreaded
+      - leans on stdlib impls so shouldn't matter?
     """
 
     def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:

omlish/dataclasses/__init__.py

@@ -159,6 +159,8 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         is_immediate_dataclass,
 
         dataclass_maybe_post_init as maybe_post_init,
+
+        dataclass_descriptor_method as descriptor_method,
     )
 
 

omlish/funcs/guard.py

@@ -18,7 +18,7 @@ P = ta.ParamSpec('P')
 
 
 class GuardFn(ta.Protocol[P, T_co]):
-    def __get__(self, instance, owner=None) -> ta.Self: ...
+    def __get__(self, instance, owner=None): ...
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T_co] | None: ...
 
@@ -53,12 +53,19 @@ class MultiGuardFn(ta.Generic[P, T]):
     def __init__(
             self,
             *children: GuardFn[P, T],
+            default: GuardFn[P, T] | None = None,
             strict: bool = False,
     ) -> None:
-        self._children, self._strict = children, strict
+        self._children, self._default, self._strict = children, default, strict
+
+    lang.attr_ops(lambda self: (
+        self._children,
+        self._default,
+        self._strict,
+    )).install(locals())
 
     def __get__(self, instance, owner=None):
-        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), strict=self._strict)  # noqa
+        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), default=self._default.__get__(instance, owner) if self._default is not None else None, strict=self._strict)  # noqa
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
         matches = []
@@ -68,7 +75,10 @@ class MultiGuardFn(ta.Generic[P, T]):
                     return m
                 matches.append(m)
         if not matches:
-            return None
+            if (dfl := self._default) is not None:
+                return dfl(*args, **kwargs)
+            else:
+                return None
         elif len(matches) > 1:
             raise AmbiguousGuardFnError
         else:
@@ -88,13 +98,13 @@ class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
             strict: bool = False,
             requires_override: bool = False,
             instance_cache: bool = False,
-            prototype: ta.Callable[P, T] | None = None,
+            default: GuardFn[P, T] | None = None,
     ) -> None:
         super().__init__()
 
         self._strict = strict
         self._instance_cache = instance_cache
-        self._prototype = prototype
+        self._default = default
 
         self._registry: col.AttrRegistry[ta.Callable, None] = col.AttrRegistry(
             requires_override=requires_override,
@@ -122,6 +132,7 @@ class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
     def _prepare(self, instance_cls: type, collected: ta.Mapping[str, tuple[ta.Callable, None]]) -> MultiGuardFn:
         return MultiGuardFn(
             *[getattr(instance_cls, a) for a in collected],
+            default=self._default,
             strict=self._strict,
         )
 
@@ -153,6 +164,7 @@ class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
 #
 
 
+@ta.final
 class GuardFnMethod(_BaseGuardFnMethod[P, T]):
     def _bind(self, instance, owner):
         return self._cache.get(type(instance)).__get__(instance, owner)  # noqa
@@ -166,13 +178,14 @@ def method(
         strict: bool = False,
         requires_override: bool = False,
         instance_cache: bool = False,
+        default: bool = False,
 ) -> ta.Callable[[ta.Callable[P, T]], GuardFnMethod[P, T]]:  # noqa
     def inner(fn):
         return GuardFnMethod(
             strict=strict,
             requires_override=requires_override,
             instance_cache=instance_cache,
-            prototype=fn,
+            default=fn if default else None,
         )
 
     return inner
@@ -181,15 +194,13 @@ def method(
 #
 
 
-class DumbGuardFnMethod(_BaseGuardFnMethod[P, T]):
+@ta.final
+class ImmediateGuardFnMethod(_BaseGuardFnMethod[P, T]):
     def _bind(self, instance, owner):
         gf = self._cache.get(type(instance)).__get__(instance, owner)  # noqa
-        x = self._prototype.__get__(instance, owner)  # type: ignore
 
         def inner(*args, **kwargs):
-            if (m := gf(*args, **kwargs)) is not None:
-                return m()
-            return x(*args, **kwargs)
+            return gf(*args, **kwargs)()  # Note: cannot be None due to non-optional default
 
         return inner
 
@@ -197,18 +208,18 @@ class DumbGuardFnMethod(_BaseGuardFnMethod[P, T]):
         return self._call(*args, **kwargs)
 
 
-def dumb_method(
+def immediate_method(
         *,
         strict: bool = False,
         requires_override: bool = False,
         instance_cache: bool = False,
-) -> ta.Callable[[ta.Callable[P, T]], DumbGuardFnMethod[P, T]]:  # noqa
+) -> ta.Callable[[ta.Callable[P, T]], ImmediateGuardFnMethod[P, T]]:  # noqa
     def inner(fn):
-        return DumbGuardFnMethod(
+        return ImmediateGuardFnMethod(
             strict=strict,
             requires_override=requires_override,
             instance_cache=instance_cache,
-            prototype=fn,
+            default=(lambda *args, **kwargs: lambda: fn(*args, **kwargs)),
         )
 
     return inner

omlish/lang/__init__.py

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

omlish/lang/functions.py

@@ -59,11 +59,11 @@ def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
 ##
 
 
-def raise_(o: BaseException) -> ta.NoReturn:
+def raise_(o: BaseException | type[BaseException]) -> ta.NoReturn:
     raise o
 
 
-def raising(o: BaseException) -> ta.Callable[..., ta.NoReturn]:
+def raising(o: BaseException | type[BaseException]) -> ta.Callable[..., ta.NoReturn]:
     def inner(*args, **kwargs):
         raise o
 

omlish/lang/iterables.py

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

omlish/lite/attrops.py

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

omlish/lite/dataclasses.py

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

omlish/marshal/__init__.py

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

omlish/marshal/base/contexts.py

@@ -5,7 +5,6 @@ from ... import check
 from ... import collections as col
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .configs import EMPTY_CONFIG_REGISTRY
 from .configs import ConfigRegistry
 from .errors import UnhandledTypeError
@@ -28,7 +27,7 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class BaseContext(lang.Abstract):
+class BaseContext(lang.Abstract, lang.Sealed):
     config_registry: ConfigRegistry = EMPTY_CONFIG_REGISTRY
     options: col.TypeMap[Option] = col.TypeMap()
 
@@ -41,33 +40,47 @@ class BaseContext(lang.Abstract):
         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)
-        fac = check.not_none(self.factory)
-        try:
-            return fac.make_marshaler(self, rty)
-        except mfs.MatchGuardError:
+        fac = check.not_none(self.marshaler_factory)
+        if (mfn := 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 mfn()
 
 
 @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)
-        fac = check.not_none(self.factory)
-        try:
-            return fac.make_unmarshaler(self, rty)
-        except mfs.MatchGuardError:
+        fac = check.not_none(self.unmarshaler_factory)
+        if (mfn := fac.make_unmarshaler(self, rty)) is None:
             raise UnhandledTypeError(rty)  # noqa
+        return mfn()
+
+
+#
+
+
+@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:
@@ -78,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/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(
+            config_registry=self.config_registry(),
+            marshaler_factory=self.marshaler_factory(),
+        )
+
+    def new_unmarshal_factory_context(self) -> UnmarshalFactoryContext:
+        return UnmarshalFactoryContext(
+            config_registry=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,
+            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,
+            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))