hypothesis: rename attribute and parameter for type strategies.

Author: pradeep90

docs/pages/contrib/hypothesis_plugins.rst

@@ -146,7 +146,7 @@ You can also register strategies for other types:
   check_all_laws(
       Number,
       container_strategy=st.builds(Number, st.integers()),
-      other_strategies={Foo: st.builds(Foo, st.text())},
+      type_strategies={Foo: st.builds(Foo, st.text())},
   )
 
 These custom strategies will be used only when running the tests generated by

returns/contrib/hypothesis/laws.py

@@ -26,6 +26,10 @@
 class Settings:
     """Settings for the law tests.
 
+    This sets the context for each generated law test, by temporarily
+    registering strategies for various types and passing any ``hypothesis``
+    settings.
+
     Any settings passed by the user will override the value from
     :func:`default_settings`.
     """
@@ -40,10 +44,11 @@ class Settings:
     #: of a container using:
     #: :func:`returns.contrib.hypothesis.containers.strategy_from_container`.
     container_strategy: StrategyFactory | None
-    #: Strategies for generating values of other types. This can be useful for
-    #: overriding ``TypeVar``, ``Callable``, etc. in case you use certain
-    #: types that ``hypothesis`` is unable to find.
-    other_strategies: dict[type[object], StrategyFactory]
+    #: Strategies for generating values of types other than the container and
+    #: its lawful interfaces. This can be useful for overriding ``TypeVar``,
+    #: ``Callable``, etc. in case you use certain types that ``hypothesis`` is
+    #: unable to find.
+    type_strategies: dict[type[object], StrategyFactory]
 
     def __post_init__(self) -> None:
         """Check that the settings are mutually compatible."""
@@ -61,7 +66,7 @@ def __or__(self, other: Self) -> Self:
             container_strategy=self.container_strategy
             if other.container_strategy is None
             else other.container_strategy,
-            other_strategies=self.other_strategies | other.other_strategies,
+            type_strategies=self.type_strategies | other.type_strategies,
         )
 
 
@@ -86,7 +91,7 @@ def default_settings(container_type: type[Lawful]) -> Settings:
         settings_kwargs={},
         use_init=False,
         container_strategy=None,
-        other_strategies={
+        type_strategies={
             TypeVar: type_vars_factory,  # type: ignore[dict-item]
             Callable: pure_functions_factory,  # type: ignore[dict-item]
         },
@@ -99,7 +104,7 @@ def check_all_laws(
     *,
     container_strategy: StrategyFactory[Example_co],
     settings_kwargs: dict[str, Any] | None = None,
-    other_strategies: dict[type[object], StrategyFactory] | None = None,
+    type_strategies: dict[type[object], StrategyFactory] | None = None,
 ) -> None: ...
 
 
@@ -118,7 +123,7 @@ def check_all_laws(
     settings_kwargs: dict[str, Any] | None = None,
     use_init: bool = False,
     container_strategy: StrategyFactory[Example_co] | None = None,
-    other_strategies: dict[type[object], StrategyFactory] | None = None,
+    type_strategies: dict[type[object], StrategyFactory] | None = None,
 ) -> None:
     """
     Function to check all defined mathematical laws in a specified container.
@@ -150,7 +155,7 @@ def check_all_laws(
         settings_kwargs or {},
         use_init,
         container_strategy,
-        other_strategies=other_strategies or {},
+        type_strategies=type_strategies or {},
     )
 
     for interface, laws in container_type.laws().items():
@@ -282,7 +287,7 @@ def _types_to_strategies(
     settings: Settings,
 ) -> dict[type[object], StrategyFactory]:
     """Return a mapping from type to `hypothesis` strategy."""
-    return settings.other_strategies | _container_mapping(
+    return settings.type_strategies | _container_mapping(
         container_type, settings
     )
 

tests/test_contrib/test_hypothesis/test_laws/test_custom_strategy_for_callable.py

@@ -150,12 +150,12 @@ def _callable_factory(thing: type[object]) -> StrategyFactory[Callable]:
             raise NotImplementedError
 
 
-other_strategies: dict[type[object], StrategyFactory] = {
+type_strategies: dict[type[object], StrategyFactory] = {
     Callable: _callable_factory  # type: ignore[dict-item]
 }
 
 check_all_laws(
     _Wrapper,
     container_strategy=st.builds(_Wrapper, st.integers()),
-    other_strategies=other_strategies,
+    type_strategies=type_strategies,
 )

tests/test_contrib/test_hypothesis/test_type_resolution.py

@@ -120,13 +120,13 @@ def test_merge_settings() -> None:
         settings_kwargs={'a': 1, 'b': 2},
         use_init=False,
         container_strategy=st.integers(),
-        other_strategies={int: st.integers(max_value=10), str: st.text('abc')},
+        type_strategies={int: st.integers(max_value=10), str: st.text('abc')},
     )
     settings2 = Settings(
         settings_kwargs={'a': 1, 'c': 3},
         use_init=False,
         container_strategy=st.integers(max_value=20),
-        other_strategies={int: st.integers(max_value=30), bool: st.booleans()},
+        type_strategies={int: st.integers(max_value=30), bool: st.booleans()},
     )
 
     result = settings1 | settings2
@@ -135,7 +135,7 @@ def test_merge_settings() -> None:
         settings_kwargs={'a': 1, 'b': 2, 'c': 3},
         use_init=False,
         container_strategy=st.integers(max_value=20),
-        other_strategies={
+        type_strategies={
             int: st.integers(max_value=30),
             bool: st.booleans(),
             str: st.text('abc'),
@@ -153,13 +153,13 @@ def test_merge_use_init() -> None:
         settings_kwargs={},
         use_init=False,
         container_strategy=None,
-        other_strategies={},
+        type_strategies={},
     )
     settings2 = Settings(
         settings_kwargs={},
         use_init=True,
         container_strategy=None,
-        other_strategies={},
+        type_strategies={},
     )
 
     result = settings1 | settings2
@@ -168,7 +168,7 @@ def test_merge_use_init() -> None:
         settings_kwargs={},
         use_init=True,
         container_strategy=None,
-        other_strategies={},
+        type_strategies={},
     )
 
 
@@ -234,7 +234,7 @@ def test_types_to_strategies_overrides() -> None:  # noqa: WPS210
             settings_kwargs={},
             use_init=False,
             container_strategy=st.builds(container_type, st.integers()),
-            other_strategies={
+            type_strategies={
                 TypeVar: st.text(),
                 callable_type: st.functions(returns=st.booleans()),
                 # This strategy does not get used, because we use

typesafety/test_contrib/test_hypothesis/test_laws/test_check_all_laws.yml

@@ -48,7 +48,7 @@
   out: |
     main:8: error: No overload variant of "check_all_laws" matches argument types "Type[Result[_ValueType_co, _ErrorType_co]]", "bool", "SearchStrategy[Success[Any]]"  [call-overload]
     main:8: note: Possible overload variants:
-    main:8: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, container_strategy: Union[SearchStrategy[Example_co], Callable[[Type[Example_co]], SearchStrategy[Example_co]]], settings_kwargs: Optional[Dict[str, Any]] = ..., other_strategies: Optional[Dict[Type[object], Union[SearchStrategy[Any], Callable[[Type[Any]], SearchStrategy[Any]]]]] = ...) -> None
+    main:8: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, container_strategy: Union[SearchStrategy[Example_co], Callable[[Type[Example_co]], SearchStrategy[Example_co]]], settings_kwargs: Optional[Dict[str, Any]] = ..., type_strategies: Optional[Dict[Type[object], Union[SearchStrategy[Any], Callable[[Type[Any]], SearchStrategy[Any]]]]] = ...) -> None
     main:8: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, settings_kwargs: Optional[Dict[str, Any]] = ..., use_init: bool = ...) -> None
 
 - case: test_all_laws_requires_container_strategy
@@ -64,11 +64,11 @@
     from returns.contrib.hypothesis.laws import check_all_laws
     from returns.result import Result, Success
 
-    check_all_laws(Result, container_strategy=st.builds(Success, st.integers()), other_strategies={int: st.integers()})
-    check_all_laws(Result, other_strategies={int: st.integers()})
+    check_all_laws(Result, container_strategy=st.builds(Success, st.integers()), type_strategies={int: st.integers()})
+    check_all_laws(Result, type_strategies={int: st.integers()})
 
   out: |
     main:6: error: No overload variant of "check_all_laws" matches argument types "Type[Result[_ValueType_co, _ErrorType_co]]", "Dict[Type[int], SearchStrategy[int]]"  [call-overload]
     main:6: note: Possible overload variants:
-    main:6: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, container_strategy: Union[SearchStrategy[Example_co], Callable[[Type[Example_co]], SearchStrategy[Example_co]]], settings_kwargs: Optional[Dict[str, Any]] = ..., other_strategies: Optional[Dict[Type[object], Union[SearchStrategy[Any], Callable[[Type[Any]], SearchStrategy[Any]]]]] = ...) -> None
+    main:6: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, container_strategy: Union[SearchStrategy[Example_co], Callable[[Type[Example_co]], SearchStrategy[Example_co]]], settings_kwargs: Optional[Dict[str, Any]] = ..., type_strategies: Optional[Dict[Type[object], Union[SearchStrategy[Any], Callable[[Type[Any]], SearchStrategy[Any]]]]] = ...) -> None
     main:6: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, settings_kwargs: Optional[Dict[str, Any]] = ..., use_init: bool = ...) -> None