rust-ok 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

rust_ok/__init__.py

@@ -1,9 +1,13 @@
 """Public API for rust-ok."""
 
-from .exceptions import IsNotError, RustOkError, UnwrapError
+from importlib.metadata import version
+
+__version__ = version("rust_ok")
+
 from .err import Err
-from .ok import Ok
+from .exceptions import IsNotError, RustOkError, UnwrapError
 from .guards import is_err, is_ok
+from .ok import Ok
 from .result import Result
 from .trace import format_exception_chain, iter_causes
 
@@ -18,4 +22,5 @@ __all__ = [
     "iter_causes",
     "is_err",
     "is_ok",
+    "__version__",
 ]

rust_ok/err.py

@@ -2,24 +2,31 @@
 
 from __future__ import annotations
 
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+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",)
 
-    def __init__(self, error: E) -> None:
+    @overload
+    def __init__(self: Err[Never, E_co], error: E_co) -> None: ...
+
+    @overload
+    def __init__(self: Err[Any, Any], error: Any) -> None: ...
+
+    def __init__(self, error: E_co | Any) -> None:
         self._error_value = error
 
     def __repr__(self) -> str:
@@ -39,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:
@@ -60,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: Optional[str] = None,
-    ) -> T:
+        context: str | None = None,
+    ) -> T_co:
         payload = self._error_value
         msg = context if context is not None else str(payload)
 

rust_ok/ok.py

@@ -2,33 +2,37 @@
 
 from __future__ import annotations
 
-from typing import Callable, Literal, Optional, TypeVar, cast, overload
+from collections.abc import Callable
+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[None, E]", value: Literal[None] = None) -> None: ...
+    def __init__(self: Ok[T_co, Never], value: T_co) -> None: ...
 
     @overload
-    def __init__(self: "Ok[T, E]", value: T) -> None: ...
+    def __init__(self: Ok[Any, Any]) -> None: ...
 
-    def __init__(self, value: Optional[T] = None) -> None:
-        self.value = cast(T, value)
+    @overload
+    def __init__(self: Ok[None, Any], value: Literal[None]) -> None: ...
+
+    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})"
@@ -47,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:
@@ -68,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 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 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/result.py

@@ -2,36 +2,39 @@
 
 from __future__ import annotations
 
-from typing import Callable, Generic, Optional, TypeVar
+from collections.abc import Callable
+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
 
@@ -47,39 +50,39 @@ 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()
 
     def unwrap_or_raise(
         self,
         exc_type: type[BaseException] = Exception,
-        context: Optional[str] = None,
-    ) -> T:
+        context: str | None = None,
+    ) -> T_co:
         """Return the Ok value or raise `exc_type`."""
         raise NotImplementedError  # pragma: no cover

rust_ok/trace.py

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from io import StringIO
-from typing import Iterator
 
 
 def iter_causes(exc: BaseException) -> Iterator[BaseException]:

{rust_ok-0.1.0.dist-info → rust_ok-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rust-ok
-Version: 0.1.0
+Version: 0.2.1
 Summary: Rust-inspired Result/Ok/Err primitives for Python
 Keywords: result,error-handling,rust,functional,typing
 Author: pesap
@@ -33,7 +33,7 @@ License: BSD 3-Clause License
          CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
          OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Natural Language :: English

rust_ok-0.2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+rust_ok/__init__.py,sha256=bPwWnvWo4gP5YZxYgcTFd5VlYNM1p37-r_32Ge6K6ic,523
+rust_ok/err.py,sha256=LUBoF_OVzzm3Vp9CzyK1ztyrGsVrqp-ZzmFxN_WjXrs,2872
+rust_ok/exceptions.py,sha256=G2FC6K6bBYrbpqUlf7paNp2M0aNWKPC_Onh5toVoOcs,325
+rust_ok/guards.py,sha256=83zQfZPBERs1oO3qrHXrrw74rwKNnp9VQOLTlbjeZbM,496
+rust_ok/ok.py,sha256=MGWZUkzBplrl2lYJ3d5Y8d_XCDI23Si-ZzG7nHe5dbI,2688
+rust_ok/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rust_ok/result.py,sha256=3F4DIuQzZiM8UB80GkvGXFThgUs0ESe21CCgbRnLDJ8,3183
+rust_ok/trace.py,sha256=yUSTkGC5U6rpFGoe6Yzrs4kN7DEkh5soCFO6JxNZAPw,1218
+rust_ok-0.2.1.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+rust_ok-0.2.1.dist-info/METADATA,sha256=eRW9TT1dR-zYaolo0vlxqHlddPMGbVP9x_r1s1tw3aw,3300
+rust_ok-0.2.1.dist-info/RECORD,,

{rust_ok-0.1.0.dist-info → rust_ok-0.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.10
+Generator: uv 0.9.26
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any

rust_ok-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-rust_ok/__init__.py,sha256=QvHZuMC8oYbIesOeDINf9QkoD-CoQQXS7KFjPs3hIeA,430
-rust_ok/err.py,sha256=L7YaUbGJzy7Q1XOKmx1iYGUuwQh1eWADUBhZrke6PDM,2382
-rust_ok/exceptions.py,sha256=G2FC6K6bBYrbpqUlf7paNp2M0aNWKPC_Onh5toVoOcs,325
-rust_ok/guards.py,sha256=83zQfZPBERs1oO3qrHXrrw74rwKNnp9VQOLTlbjeZbM,496
-rust_ok/ok.py,sha256=iHj8dWyoB8J-VRQUpQgLJ8nWsS_xZIVAbnexeCqg8K0,2243
-rust_ok/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rust_ok/result.py,sha256=fdcI3WjXqaeHMEDaOXGCThuwz7SALtJ9aKKDwmg8628,2949
-rust_ok/trace.py,sha256=WGuwRHMjCIiXztyLHLUIyNq2DfJbdZ1oW85FrrcZojo,1209
-rust_ok-0.1.0.dist-info/WHEEL,sha256=ZHijuPszqKbNczrBXkSuoxdxocbxgFghqnequ9ZQlVk,79
-rust_ok-0.1.0.dist-info/METADATA,sha256=rtE8Hk2Zfzq_2I08r2veZlCuVkkul-WsOKgMUyGQSNQ,3301
-rust_ok-0.1.0.dist-info/RECORD,,