Rust’s Result type in Python

result.py

from typing import TypeVar, Tuple, Generic

T = TypeVar('T')
E = TypeVar('E')

class Result(Generic[T, E]):
    def __init__(self, value: T=None, error: E=None):
        self.value = value
        self.error = error
        
    def is_ok(self) -> bool:
        return self.value is not None
    
    def is_err(self) -> bool:
        return self.error is not None
    
    def unwrap(self) -> T:
        if self.is_ok():
            return self.value
        else:
            raise ValueError("Called unwrap() on an error Result")
    
    def expect(self, message: str) -> T:
        if self.is_ok():
            return self.value
        else:
            raise ValueError(message)
    
    def unwrap_err(self) -> E:
        if self.is_err():
            return self.error
        else:
            raise ValueError("Called unwrap_err() on an ok Result")
    
    def expect_err(self, message: str) -> E:
        if self.is_err():
            return self.error
        else:
            raise ValueError(message)
    
    def map(self, f: Callable[[T], U]) -> 'Result[U, E]':
        if self.is_ok():
            return Result(f(self.value))
        else:
            return Result(error=self.error)
    
    def map_err(self, f: Callable[[E], F]) -> 'Result[T, F]':
        if self.is_err():
            return Result(error=f(self.error))
        else:
            return Result(value=self.value)