refactoring: Add ignore_none_type option for type standardization

injection/_core/common/type.py

@@ -72,9 +72,10 @@ def get_yield_hint[T](
 def standardize_types(
     *types: InputType[Any],
     with_origin: bool = False,
+    ignore_none_type: bool = False,
 ) -> Iterator[TypeDef[Any]]:
     for tp in types:
-        if tp in (None, NoneType):
+        if tp is None or (ignore_none_type and tp is NoneType):
             continue
 
         origin = get_origin(tp)
@@ -101,4 +102,8 @@ def standardize_types(
 
             continue
 
-        yield from standardize_types(*inner_types, with_origin=with_origin)
+        yield from standardize_types(
+            *inner_types,
+            with_origin=with_origin,
+            ignore_none_type=ignore_none_type,
+        )

injection/_core/descriptors.py

@@ -53,7 +53,11 @@ def __generate_keys(
             if name == descriptor_name:
                 continue
 
-            key = self.__module.reserve_scoped_slot(hint, scope_name=self.__name)
+            key = self.__module.reserve_scoped_slot(
+                hint,
+                scope_name=self.__name,
+                ignore_none_type=True,
+            )
             yield name, key
 
     def __mapping_from(self, instance: object) -> dict[SlotKey[Any], Any]:

injection/_core/module.py

@@ -55,6 +55,7 @@
 from injection._core.common.threading import get_lock
 from injection._core.common.type import (
     InputType,
+    TypeDef,
     TypeInfo,
     get_return_types,
     get_yield_hint,
@@ -223,11 +224,12 @@ class Record[T](NamedTuple):
     mode: Mode
 
 
-@dataclass(repr=False, eq=False, kw_only=True, slots=True)
+@dataclass(repr=False, eq=False, frozen=True, kw_only=True, slots=True)
 class Updater[T]:
     classes: Iterable[InputType[T]]
     injectable: Injectable[T]
     mode: Mode
+    ignore_none_type: bool
 
     def make_record(self) -> Record[T]:
         return Record(self.injectable, self.mode)
@@ -239,11 +241,13 @@ def with_basics(
         /,
         injectable: Injectable[T],
         mode: Mode | ModeStr,
+        ignore_none_type: bool = False,
     ) -> Self:
         return cls(
             classes=get_return_types(on),
             injectable=injectable,
             mode=Mode(mode),
+            ignore_none_type=ignore_none_type,
         )
 
 
@@ -284,9 +288,9 @@ def __injectables(self) -> frozenset[Injectable[Any]]:
         return frozenset(record.injectable for record in self.__records.values())
 
     def update[T](self, updater: Updater[T]) -> Self:
-        updater = self.__update_preprocessing(updater)
         record = updater.make_record()
-        records = dict(self.__prepare_for_updating(updater.classes, record))
+        classes = self.__reduce_classes(updater)
+        records = dict(self.__prepare_for_updating(classes, record))
 
         if records:
             event = LocatorDependenciesUpdated(self, records.keys(), record.mode)
@@ -347,17 +351,21 @@ def __keep_new_record[T](
 
         return new_mode.rank > existing_mode.rank
 
+    @staticmethod
+    def __reduce_classes[T](updater: Updater[T]) -> frozenset[TypeDef[T]]:
+        return frozenset(
+            standardize_types(
+                *updater.classes,
+                ignore_none_type=updater.ignore_none_type,
+            )
+        )
+
     @staticmethod
     def __standardize_inputs[T](
         classes: Iterable[InputType[T]],
     ) -> Iterator[InputType[T]]:
         return standardize_types(*classes, with_origin=True)
 
-    @staticmethod
-    def __update_preprocessing[T](updater: Updater[T]) -> Updater[T]:
-        updater.classes = frozenset(standardize_types(*updater.classes))
-        return updater
-
 
 """
 Module
@@ -556,9 +564,10 @@ def reserve_scoped_slot[T](
         scope_name: str,
         *,
         mode: Mode | ModeStr = Mode.get_default(),
+        ignore_none_type: bool = False,
     ) -> SlotKey[T]:
         injectable = ScopedSlotInjectable(cls, scope_name)
-        updater = Updater.with_basics(cls, injectable, mode)
+        updater = Updater.with_basics(cls, injectable, mode, ignore_none_type)
         self.update(updater)
         return injectable.key