tessl/pypi-returns

Functional programming library providing type-safe containers for error handling, side effects, and composable operations with monadic patterns.

—

Pending

Overview

Eval results

Files

Container Methods

Name: tessl/pypi-returns
Author: tessl

Utility functions that operate on containers to provide common patterns for container manipulation, state checking, and conditional creation.

Capabilities

Conditional Container Creation

Create containers based on conditions without explicit branching logic.

def cond(
    condition: bool,
    success_value: T,
    failure_value: E
) -> Result[T, E]:
    """Create Success or Failure based on condition"""

Usage examples:

from returns.methods import cond

# Conditional Result creation
def validate_age(age: int) -> Result[int, str]:
    return cond(
        age >= 18,
        success_value=age,
        failure_value="Must be 18 or older"
    )

result = validate_age(20)  # Success(20)
result = validate_age(15)  # Failure("Must be 18 or older")

Container Partitioning

Split collections of containers into successful and failed groups.

def partition(
    containers: Iterable[Result[T, E]]
) -> tuple[list[T], list[E]]:
    """Partition Results into successes and failures"""

Usage examples:

from returns.methods import partition
from returns.result import Success, Failure

results = [
    Success(1),
    Failure("error1"),
    Success(2),
    Failure("error2"),
    Success(3)
]

successes, failures = partition(results)
# successes: [1, 2, 3]
# failures: ["error1", "error2"]

Safe Container Unwrapping

Extract values from containers with safe fallback behavior.

def unwrap_or_failure(
    container: Result[T, E],
    default_failure: F
) -> T | F:
    """Safely unwrap or return default failure"""

Usage examples:

from returns.methods import unwrap_or_failure
from returns.result import Success, Failure

# Safe extraction with default
success_value = unwrap_or_failure(Success(42), "default")  # 42
failure_value = unwrap_or_failure(Failure("error"), "default")  # "default"

# Useful for chaining operations
def process_data(data: Result[str, str]) -> str:
    clean_data = unwrap_or_failure(data, "")
    return clean_data.upper()

Integration with Containers

These methods work seamlessly with all container types and provide building blocks for more complex functional programming patterns:

from returns.methods import cond, partition
from returns.result import Success, Failure
from returns.pipeline import flow

# Complex validation pipeline
def validate_user_data(users: list[dict]) -> tuple[list[dict], list[str]]:
    validated = [
        cond(
            user.get("age", 0) >= 18 and "@" in user.get("email", ""),
            success_value=user,
            failure_value=f"Invalid user: {user.get('name', 'unknown')}"
        )
        for user in users
    ]
    
    return partition(validated)

# Usage
users = [
    {"name": "John", "age": 25, "email": "john@example.com"},
    {"name": "Jane", "age": 16, "email": "jane@example.com"},
    {"name": "Bob", "age": 30, "email": "invalid-email"}
]

valid_users, errors = validate_user_data(users)

These utilities enable cleaner, more declarative code when working with container collections and conditional logic.

Install with Tessl CLI