rust-ok 0.2.0__tar.gz → 0.2.1__tar.gz

{rust_ok-0.2.0 → rust_ok-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rust-ok
-Version: 0.2.0
+Version: 0.2.1
 Summary: Rust-inspired Result/Ok/Err primitives for Python
 Keywords: result,error-handling,rust,functional,typing
 Author: pesap

{rust_ok-0.2.0 → rust_ok-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rust-ok"
-version = "0.2.0"
+version = "0.2.1"
 description = "Rust-inspired Result/Ok/Err primitives for Python"
 readme = "README.md"
 authors = [
@@ -35,11 +35,13 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
+    "mypy>=1.19.1",
     "pre-commit>=4.5.0,<5.0.0",
+    "prek>=0.2.29",
     "pytest>=8.3.0,<9.0.0",
     "pytest-cov>=5.0.0,<6.0.0",
     "ruff>=0.6.8,<0.7.0",
-    "ty>=0.0.2",
+    "ty>=0.0.10",
 ]
 
 [tool.ruff]

{rust_ok-0.2.0 → rust_ok-0.2.1}/src/rust_ok/err.py

@@ -3,31 +3,31 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any, TypeVar, cast, overload
+from typing import Any, Never, TypeVar, cast, overload
 
 from .exceptions import UnwrapError
 from .result import Result
 
-T = TypeVar("T")
-E = TypeVar("E")
+T_co = TypeVar("T_co", covariant=True)
+E_co = TypeVar("E_co", covariant=True)
 U = TypeVar("U")
 F = TypeVar("F")
 
 
-class Err(Result[T, E]):
+class Err(Result[T_co, E_co]):
     """Error result containing an error value."""
 
     __slots__ = ("_error_value",)
     __match_args__ = ("error",)
 
     @overload
-    def __init__(self: Err[T, E], error: E) -> None: ...
+    def __init__(self: Err[Never, E_co], error: E_co) -> None: ...
 
     @overload
-    def __init__(self: Err[T, Any], error: Any) -> None: ...
+    def __init__(self: Err[Any, Any], error: Any) -> None: ...
 
-    def __init__(self, error: E | Any) -> None:
-        self._error_value = cast(E, error)
+    def __init__(self, error: E_co | Any) -> None:
+        self._error_value = error
 
     def __repr__(self) -> str:
         return f"Err({self._error_value!r})"
@@ -46,19 +46,19 @@ class Err(Result[T, E]):
     def __bool__(self) -> bool:
         return False
 
-    def unwrap(self) -> T:
+    def unwrap(self) -> T_co:
         raise UnwrapError(f"Called unwrap on Err: {self._error_value}")
 
-    def unwrap_err(self) -> E:
+    def unwrap_err(self) -> E_co:
         return self._error_value
 
-    def unwrap_or(self, default: T) -> T:
+    def unwrap_or(self, default: T_co | Any) -> T_co:
         return default
 
-    def unwrap_or_else(self, func: Callable[[E], T]) -> T:
+    def unwrap_or_else(self, func: Callable[[Any], T_co]) -> T_co:
         return func(self._error_value)
 
-    def expect(self, msg: str) -> T:
+    def expect(self, msg: str) -> T_co:
         raise UnwrapError(f"{msg}: {self._error_value}")
 
     def is_ok(self) -> bool:
@@ -67,29 +67,31 @@ class Err(Result[T, E]):
     def is_err(self) -> bool:
         return True
 
-    def map(self, func: Callable[[T], U]) -> Result[U, E]:
-        return Err(self._error_value)
+    def map(self, func: Callable[[Any], U]) -> Result[U, E_co]:
+        """Return Err; func is never called."""
+        return cast(Result[U, E_co], Err(self._error_value))
 
-    def map_err(self, func: Callable[[E], F]) -> Result[T, F]:
-        return Err(func(self._error_value))
+    def map_err(self, func: Callable[[Any], F]) -> Result[T_co, F]:
+        return cast(Result[T_co, F], Err(func(self._error_value)))
 
-    def and_then(self, func: Callable[[T], Result[U, E]]) -> Result[U, E]:
-        return Err(self._error_value)
+    def and_then(self, func: Callable[[Any], Result[U, E_co]]) -> Result[U, E_co]:
+        """Return Err; func is never called."""
+        return cast(Result[U, E_co], Err(self._error_value))
 
-    def or_else(self, func: Callable[[E], Result[T, F]]) -> Result[T, F]:
+    def or_else(self, func: Callable[[Any], Result[T_co, F]]) -> Result[T_co, F]:
         return func(self._error_value)
 
-    def ok(self) -> T | None:
+    def ok(self) -> T_co | None:
         return None
 
-    def err(self) -> E:
+    def err(self) -> E_co:
         return self._error_value
 
     def unwrap_or_raise(
         self,
         exc_type: type[BaseException] = Exception,
         context: str | None = None,
-    ) -> T:
+    ) -> T_co:
         payload = self._error_value
         msg = context if context is not None else str(payload)
 

{rust_ok-0.2.0 → rust_ok-0.2.1}/src/rust_ok/ok.py

@@ -3,36 +3,36 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any, Literal, TypeVar, cast, overload
+from typing import Any, Literal, Never, TypeVar, cast, overload
 
 from .exceptions import IsNotError, UnwrapError
 from .result import Result
 
-T = TypeVar("T")
-E = TypeVar("E")
+T_co = TypeVar("T_co", covariant=True)
+E_co = TypeVar("E_co", covariant=True)
 U = TypeVar("U")
 F = TypeVar("F")
 
 
-class Ok(Result[T, E]):
+class Ok(Result[T_co, E_co]):
     """Success result containing a value."""
 
     __slots__ = ("value",)
     __match_args__ = ("value",)
 
-    value: T
+    value: T_co
 
     @overload
-    def __init__(self: Ok[Any, Any]) -> None: ...
+    def __init__(self: Ok[T_co, Never], value: T_co) -> None: ...
 
     @overload
-    def __init__(self: Ok[None, E], value: Literal[None]) -> None: ...
+    def __init__(self: Ok[Any, Any]) -> None: ...
 
     @overload
-    def __init__(self: Ok[T, E], value: T) -> None: ...
+    def __init__(self: Ok[None, Any], value: Literal[None]) -> None: ...
 
-    def __init__(self, value: T | None = None) -> None:
-        self.value = cast(T, value)
+    def __init__(self, value: T_co | None = None) -> None:
+        self.value = value  # type: ignore[assignment]
 
     def __repr__(self) -> str:
         return f"Ok({self.value!r})"
@@ -51,19 +51,20 @@ class Ok(Result[T, E]):
     def __bool__(self) -> bool:
         return True
 
-    def unwrap(self) -> T:
+    def unwrap(self) -> T_co:
         return self.value
 
-    def unwrap_err(self) -> E:
+    def unwrap_err(self) -> E_co:
         raise UnwrapError("Called unwrap_err on Ok")
 
-    def unwrap_or(self, default: T) -> T:
+    def unwrap_or(self, default: T_co | Any) -> T_co:
         return self.value
 
-    def unwrap_or_else(self, func: Callable[[E], T]) -> T:
+    def unwrap_or_else(self, func: Callable[[Any], T_co]) -> T_co:
+        """Return value; func is never called in Ok."""
         return self.value
 
-    def expect(self, msg: str) -> T:
+    def expect(self, msg: str) -> T_co:
         return self.value
 
     def is_ok(self) -> bool:
@@ -72,27 +73,29 @@ class Ok(Result[T, E]):
     def is_err(self) -> bool:
         return False
 
-    def map(self, func: Callable[[T], U]) -> Result[U, E]:
+    def map(self, func: Callable[[Any], U]) -> Result[U, E_co]:
         return Ok(func(self.value))
 
-    def map_err(self, func: Callable[[E], F]) -> Result[T, F]:
-        return cast(Result[T, F], Ok(self.value))
+    def map_err(self, func: Callable[[Any], F]) -> Result[T_co, F]:
+        """Phantom type: func is never called in Ok."""
+        return cast(Result[T_co, F], Ok(self.value))
 
-    def and_then(self, func: Callable[[T], Result[U, E]]) -> Result[U, E]:
+    def and_then(self, func: Callable[[Any], Result[U, E_co]]) -> Result[U, E_co]:
         return func(self.value)
 
-    def or_else(self, func: Callable[[E], Result[T, F]]) -> Result[T, F]:
-        return cast(Result[T, F], Ok(self.value))
+    def or_else(self, func: Callable[[Any], Result[T_co, F]]) -> Result[T_co, F]:
+        """Phantom type: func is never called in Ok."""
+        return cast(Result[T_co, F], Ok(self.value))
 
-    def ok(self) -> T:
+    def ok(self) -> T_co:
         return self.value
 
-    def err(self) -> E:
+    def err(self) -> E_co:
         raise IsNotError
 
     def unwrap_or_raise(
         self,
         exc_type: type[BaseException] = Exception,
         context: str | None = None,
-    ) -> T:
+    ) -> T_co:
         return self.value

{rust_ok-0.2.0 → rust_ok-0.2.1}/src/rust_ok/result.py

@@ -3,36 +3,38 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Generic, TypeVar
+from typing import Any, Generic, TypeVar
 
-T = TypeVar("T")
-E = TypeVar("E")
+# Covariant type variables for Result base type
+T_co = TypeVar("T_co", covariant=True)
+E_co = TypeVar("E_co", covariant=True)
+# TypeVars for transformation method return types
 U = TypeVar("U")
 F = TypeVar("F")
 
 
-class Result(Generic[T, E]):
+class Result(Generic[T_co, E_co]):
     """Base type for Ok/Err results."""
 
     __slots__ = ()
 
-    def unwrap(self) -> T:
+    def unwrap(self) -> T_co:
         """Return the contained value if successful, else raise in subclass."""
         raise NotImplementedError  # pragma: no cover
 
-    def unwrap_err(self) -> E:
+    def unwrap_err(self) -> E_co:
         """Return the contained error if Err, else raise in subclass."""
         raise NotImplementedError  # pragma: no cover
 
-    def unwrap_or(self, default: T) -> T:
+    def unwrap_or(self, default: T_co | Any) -> T_co:
         """Return the contained value if Ok, otherwise return the default."""
         raise NotImplementedError  # pragma: no cover
 
-    def unwrap_or_else(self, func: Callable[[E], T]) -> T:
+    def unwrap_or_else(self, func: Callable[[Any], T_co]) -> T_co:
         """Return the contained value if Ok, otherwise compute a default."""
         raise NotImplementedError  # pragma: no cover
 
-    def expect(self, msg: str) -> T:
+    def expect(self, msg: str) -> T_co:
         """Return the contained value if Ok, otherwise raise with custom message."""
         raise NotImplementedError  # pragma: no cover
 
@@ -48,32 +50,32 @@ class Result(Generic[T, E]):
 
         return isinstance(self, Err)
 
-    def map(self, func: Callable[[T], U]) -> Result[U, E]:
+    def map(self, func: Callable[[Any], U]) -> Result[U, E_co]:
         """Apply func to the contained value if Ok, returning a new Result."""
         raise NotImplementedError  # pragma: no cover
 
-    def map_err(self, func: Callable[[E], F]) -> Result[T, F]:
+    def map_err(self, func: Callable[[Any], F]) -> Result[T_co, F]:
         """Apply func to the error if Err, returning a new Result."""
         raise NotImplementedError  # pragma: no cover
 
-    def and_then(self, func: Callable[[T], Result[U, E]]) -> Result[U, E]:
+    def and_then(self, func: Callable[[Any], Result[U, E_co]]) -> Result[U, E_co]:
         """Chain another computation on the contained value if Ok."""
         raise NotImplementedError  # pragma: no cover
 
-    def or_else(self, func: Callable[[E], Result[T, F]]) -> Result[T, F]:
+    def or_else(self, func: Callable[[Any], Result[T_co, F]]) -> Result[T_co, F]:
         """Handle the error by calling func if Err, returning a new Result."""
         raise NotImplementedError  # pragma: no cover
 
-    def ok(self) -> T | None:
+    def ok(self) -> T_co | None:
         """Return the success value if Ok, otherwise None."""
         raise NotImplementedError  # pragma: no cover
 
-    def err(self) -> E:
+    def err(self) -> E_co:
         """Return the error value if Err, otherwise raise in subclass."""
         raise NotImplementedError  # pragma: no cover
 
     @property
-    def error(self) -> E | None:
+    def error(self) -> E_co | None:
         """Return the error value if Err, otherwise None."""
         return self.err()
 
@@ -81,6 +83,6 @@ class Result(Generic[T, E]):
         self,
         exc_type: type[BaseException] = Exception,
         context: str | None = None,
-    ) -> T:
+    ) -> T_co:
         """Return the Ok value or raise `exc_type`."""
         raise NotImplementedError  # pragma: no cover