# exp.py
from typing import Union, Generic, TypeVar
from typing_extensions import TypeIs

T = TypeVar('T', covariant=True)
E = TypeVar('E', covariant=True)


class Ok(Generic[T]):
    def __init__(self, value: T):
        self._value = value
    
    @property
    def ok_value(self) -> T:
        return self._value
    
    def is_err(self) -> bool:
        return False


class Err(Generic[E]):
    def __init__(self, error: E):
        self._error = error
    
    @property
    def err_value(self) -> E:
        return self._error
    
    def is_err(self) -> bool:
        return True


Result = Union[Ok[T], Err[E]]


def is_err(result: Result[T, E]) -> TypeIs[Err[E]]:
    """Type guard to check if a result is an Err"""
    return result.is_err()

# ------------------------------------------------------------

def some_function() -> Result[int, Exception]:
    condition = False
    if condition is False:
        return Err(Exception("Test error"))
    return Ok(1)

def use_some_function():    
    result = some_function()
    
    if is_err(result):
        print(result.err_value)
        return None

    # After the is_err() check and early return,
    # result should be narrowed to Ok[int]
    okay = result.ok_value  # <- ty reports warning here
    print(okay)