rezult 0.1.0__tar.gz

rezult-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.3
+Name: rezult
+Version: 0.1.0
+Summary: Add your description here
+Author: Sequence
+Author-email: Sequence <3863887959@qq.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+WIP

rezult-0.1.0/README.md

@@ -0,0 +1 @@
+WIP

rezult-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "rezult"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[[project.authors]]
+name = "Sequence"
+email = "3863887959@qq.com"
+
+[project.scripts]
+rezult = "rezult:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"

rezult-0.1.0/pyproject.toml.orig

@@ -0,0 +1,17 @@
+[project]
+name = "rezult"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Sequence", email = "3863887959@qq.com" }
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[project.scripts]
+rezult = "rezult:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"

rezult-0.1.0/src/rezult/__init__.py

@@ -0,0 +1,7 @@
+from .option import Nothing as Nothing
+from .option import Option as Option
+from .option import Some as Some
+from .result import Err as Err
+from .result import Ok as Ok
+from .result import Result as Result
+from .result import UnwrapError as UnwrapError

rezult-0.1.0/src/rezult/option.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Final
+from typing import Never
+from typing import Self
+
+from .result import Err
+from .result import Ok
+from .result import UnwrapError
+
+
+if TYPE_CHECKING:
+    from .result import Result
+
+
+_UNSUPPORTED = NotImplementedError("Unsupported option type")
+
+
+class Option[T]:
+    def __init__(self) -> Never:
+        raise NotImplementedError("You should implement __init__ for the variant first.")
+
+    # ==========
+    # Assertions
+    # ==========
+
+    def is_some(self) -> bool:
+        return isinstance(self, Some)
+
+    def is_some_and(self, f: Callable[[T], bool]) -> bool:
+        match self:
+            case Some(value=value):
+                return f(value)
+            case Nothing():
+                return False
+            case _:
+                raise _UNSUPPORTED
+
+    def is_none(self) -> bool:
+        return not self.is_some()
+
+    def is_none_or(self, f: Callable[[T], bool]) -> bool:
+        match self:
+            case Some(value=value):
+                return f(value)
+            case Nothing():
+                return True
+            case _:
+                raise _UNSUPPORTED
+
+    # ========
+    # Castings
+    # ========
+
+    def ok_or[E](self, err: E) -> Result[T, E]:
+        match self:
+            case Some(value=value):
+                return Ok(value)
+            case Nothing():
+                return Err(err)
+            case _:
+                raise _UNSUPPORTED
+
+    def ok_or_else[E](self, op: Callable[[], E]) -> Result[T, E]:
+        match self:
+            case Some(value=value):
+                return Ok(value)
+            case Nothing():
+                return Err(op())
+            case _:
+                raise _UNSUPPORTED
+
+    # ========
+    # Mappings
+    # ========
+
+    def map[U](self, op: Callable[[T], U]) -> Option[U]:
+        match self:
+            case Some(value=value):
+                return Some(op(value))
+            case Nothing():
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    def map_or[U](self, default: U, f: Callable[[T], U]) -> U:
+        match self:
+            case Some(value=value):
+                return f(value)
+            case Nothing():
+                return default
+            case _:
+                raise _UNSUPPORTED
+
+    def map_or_else[U](self, default: Callable[[], U], f: Callable[[T], U]) -> U:
+        match self:
+            case Some(value=value):
+                return f(value)
+            case Nothing():
+                return default()
+            case _:
+                raise _UNSUPPORTED
+
+    # ===========
+    # Inspectings
+    # ===========
+
+    def inspect(self, f: Callable[[T], None]) -> Self:
+        if isinstance(self, Some):
+            f(self.value)
+        return self
+
+    # ==========
+    # Unwrapping
+    # ==========
+
+    def unwrap(self) -> T:
+        match self:
+            case Some(value=value):
+                return value
+            case Nothing():
+                raise UnwrapError("Called unwrap on a Nothing value")
+            case _:
+                raise _UNSUPPORTED
+
+    def unwrap_or(self, default: T) -> T:
+        match self:
+            case Some(value=value):
+                return value
+            case Nothing():
+                return default
+            case _:
+                raise _UNSUPPORTED
+
+    def unwrap_or_else(self, op: Callable[[], T]) -> T:
+        match self:
+            case Some(value=value):
+                return value
+            case Nothing():
+                return op()
+            case _:
+                raise _UNSUPPORTED
+
+    def expect(self, msg: str) -> T:
+        match self:
+            case Some(value=value):
+                return value
+            case Nothing():
+                raise UnwrapError(msg)
+            case _:
+                raise _UNSUPPORTED
+
+    # =========
+    # Filtering
+    # =========
+
+    def filter(self, predicate: Callable[[T], bool]) -> Option[T]:
+        match self:
+            case Some(value=value):
+                return self if predicate(value) else Nothing()
+            case Nothing():
+                return self
+            case _:
+                raise _UNSUPPORTED
+
+    # =========
+    # Operating
+    # =========
+
+    def and_opt[U](self, opt: Option[U]) -> Option[U]:
+        match self:
+            case Some():
+                return opt
+            case Nothing():
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    def and_then_opt[U](self, op: Callable[[T], Option[U]]) -> Option[U]:
+        match self:
+            case Some(value=value):
+                return op(value)
+            case Nothing():
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    def or_opt(self, opt: Option[T]) -> Option[T]:
+        match self:
+            case Some():
+                return self
+            case Nothing():
+                return opt
+            case _:
+                raise _UNSUPPORTED
+
+    def or_else_opt(self, op: Callable[[], Option[T]]) -> Option[T]:
+        match self:
+            case Some():
+                return self
+            case Nothing():
+                return op()
+            case _:
+                raise _UNSUPPORTED
+
+    def xor(self, opt: Option[T]) -> Option[T]:
+        match (self, opt):
+            case (Some() as some, Nothing()):
+                return some
+            case (Nothing(), Some() as some):
+                return some
+            case (Some(), Some()):
+                return Nothing()
+            case (Nothing(), Nothing()):
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    def zip[U](self, other: Option[U]) -> Option[tuple[T, U]]:
+        match (self, other):
+            case (Some(value=left), Some(value=right)):
+                return Some((left, right))
+            case (Some(), Nothing()) | (Nothing(), Some()) | (Nothing(), Nothing()):
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    # =============
+    # Transformings
+    # =============
+
+    @classmethod
+    def flatten(cls, option: Option[Option[T]]) -> Option[T]:
+        match option:
+            case Some(value=inner):
+                return inner
+            case Nothing():
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    @classmethod
+    def transpose[E](cls, option: Option[Result[T, E]]) -> Result[Option[T], E]:
+        match option:
+            case Some(value=Ok(value=value)):
+                return Ok(Some(value))
+            case Some(value=Err(value=value)):
+                return Err(value)
+            case Nothing():
+                return Ok(Nothing())
+            case _:
+                raise _UNSUPPORTED
+
+
+class Some[T](Option[T]):
+    __slots__ = ("value",)
+
+    def __init__(self, value: T) -> None:
+        self.value: Final = value
+
+
+class Nothing(Option[Any]):
+    __slots__ = ()
+
+    def __init__(self) -> None:
+        pass

rezult-0.1.0/src/rezult/result.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Final
+from typing import Never
+from typing import Self
+
+
+if TYPE_CHECKING:
+    from .option import Option
+
+
+_UNSUPPORTED = NotImplementedError("Unsupported result type")
+
+
+class UnwrapError(Exception):
+    ...
+
+
+class Result[T, E]:
+    def __init__(self) -> Never:
+        raise NotImplementedError("You should implement __init__ for the variant first.")
+
+    # ==========
+    # Assertions
+    # ==========
+
+    def is_ok(self) -> bool:
+        return isinstance(self, Ok)
+
+    def is_ok_and(self, f: Callable[[T], bool]) -> bool:
+        match self:
+            case Ok(value=value):
+                return f(value)
+            case Err():
+                return False
+            case _:
+                raise _UNSUPPORTED
+
+    def is_err(self) -> bool:
+        return not self.is_ok()
+
+    def is_err_and(self, f: Callable[[E], bool]) -> bool:
+        match self:
+            case Ok():
+                return False
+            case Err(value=value):
+                return f(value)
+            case _:
+                raise _UNSUPPORTED
+
+    # ========
+    # Castings
+    # ========
+
+    def ok(self) -> Option[T]:
+        from .option import Nothing
+        from .option import Some
+
+        match self:
+            case Ok(value=value):
+                return Some(value)
+            case Err():
+                return Nothing()
+            case _:
+                raise _UNSUPPORTED
+
+    def err(self) -> Option[E]:
+        from .option import Nothing
+        from .option import Some
+
+        match self:
+            case Ok():
+                return Nothing()
+            case Err(value=value):
+                return Some(value)
+            case _:
+                raise _UNSUPPORTED
+
+    # ========
+    # Mappings
+    # ========
+
+    def map[U](self, op: Callable[[T], U]) -> Result[U, E]:
+        match self:
+            case Ok(value=value):
+                return Ok(op(value))
+            case Err(value=value):
+                return Err(value)
+            case _:
+                raise _UNSUPPORTED
+
+    def map_or[U](self, default: U, f: Callable[[T], U]) -> U:
+        match self:
+            case Ok(value=value):
+                return f(value)
+            case Err():
+                return default
+            case _:
+                raise _UNSUPPORTED
+
+    def map_err[F](self, op: Callable[[E], F]) -> Result[T, F]:
+        match self:
+            case Ok(value=value):
+                return Ok(value)
+            case Err(value=value):
+                return Err(op(value))
+            case _:
+                raise _UNSUPPORTED
+
+    # ===========
+    # Inspectings
+    # ===========
+
+    def inspect(self, f: Callable[[T], None]) -> Self:
+        if isinstance(self, Ok):
+            f(self.value)
+        return self
+
+    def inspect_err(self, f: Callable[[E], None]) -> Self:
+        if isinstance(self, Err):
+            f(self.value)
+        return self
+
+    # ==========
+    # Unwrapping
+    # ==========
+
+    def unwrap(self) -> T:
+        match self:
+            case Ok(value=value):
+                return value
+            case Err(value=value):
+                raise UnwrapError(value)
+            case _:
+                raise _UNSUPPORTED
+
+    def unwrap_or(self, default: T) -> T:
+        match self:
+            case Ok(value=value):
+                return value
+            case Err():
+                return default
+            case _:
+                raise _UNSUPPORTED
+
+    def unwrap_or_else(self, op: Callable[[E], T]) -> T:
+        match self:
+            case Ok(value=value):
+                return value
+            case Err(value=value):
+                return op(value)
+            case _:
+                raise _UNSUPPORTED
+
+    def expect(self, msg: str) -> T:
+        match self:
+            case Ok(value=value):
+                return value
+            case Err():
+                raise UnwrapError(msg)
+            case _:
+                raise _UNSUPPORTED
+
+    def unwrap_err(self) -> E:
+        match self:
+            case Ok(value=value):
+                raise UnwrapError(value)
+            case Err(value=value):
+                return value
+            case _:
+                raise _UNSUPPORTED
+
+    def expect_err(self, msg: str) -> E:
+        match self:
+            case Ok():
+                raise UnwrapError(msg)
+            case Err(value=value):
+                return value
+            case _:
+                raise _UNSUPPORTED
+
+    # =========
+    # Operating
+    # =========
+
+    def and_res[U](self, res: Result[U, E]) -> Result[U, E]:
+        match self:
+            case Ok():
+                return res
+            case Err(value=value):
+                return Err(value)
+            case _:
+                raise _UNSUPPORTED
+
+    def and_then_res[U](self, op: Callable[[T], Result[U, E]]) -> Result[U, E]:
+        match self:
+            case Ok(value=value):
+                return op(value)
+            case Err(value=value):
+                return Err(value)
+            case _:
+                raise _UNSUPPORTED
+
+    def or_res[F](self, res: Result[T, F]) -> Result[T, F]:
+        match self:
+            case Ok(value=value):
+                return Ok(value)
+            case Err():
+                return res
+            case _:
+                raise _UNSUPPORTED
+
+    def or_else_res[F](self, op: Callable[[E], Result[T, F]]) -> Result[T, F]:
+        match self:
+            case Ok(value=value):
+                return Ok(value)
+            case Err(value=value):
+                return op(value)
+            case _:
+                raise _UNSUPPORTED
+
+    @classmethod
+    def transpose(cls, result: Result[Option[T], E]) -> Option[Result[T, E]]:
+        from .option import Nothing
+        from .option import Some
+
+        match result:
+            case Ok(value=Some(value=value)):
+                return Some(Ok(value))
+            case Ok(value=Nothing()):
+                return Nothing()
+            case Err(value=value):
+                return Some(Err(value))
+            case _:
+                raise _UNSUPPORTED
+
+    @classmethod
+    def flatten(cls, result: Result[Result[T, E], E]) -> Result[T, E]:
+        match result:
+            case Ok(value=inner):
+                return inner
+            case Err(value=value):
+                return Err(value)
+            case _:
+                raise _UNSUPPORTED
+
+
+class Ok[T](Result[T, Any]):
+    __slots__ = ("value",)
+
+    def __init__(self, value: T) -> None:
+        self.value: Final = value
+
+
+class Err[E](Result[Any, E]):
+    __slots__ = ("value",)
+
+    def __init__(self, value: E) -> None:
+        self.value: Final = value