python-fp

Files (1)

• SKILL.md

SKILL.md (first lines)

# Functional Python

## When to use

- Writing serializers, helpers, formatters, validators, mappers, converters — anything stateless
- Refactoring a class with a single method + `__init__` into a plain function
- A data transformation pipeline (load → filter → map → aggregate)
- Making code easier to test (a pure function = `assert f(x) == y`, no mocks)

When **not** to use: ORM models, framework extensions (Flask/Marshmallow), long-lived objects with invariants.

## 1. Pure functions

A pure function:
1. **Deterministic** — the same inputs produce the same output.
2. **No side effects** — does not write to globals, files, or the database, and does not mutate its arguments.

```python
# Bad: mutates argument + reads global
TAX = 0.2
def add_total(items):
    for it in items:
        it["total"] = it["price"] * (1 + TAX)
    return items

# Good: pure, tax is a parameter
def with_total(item: dict, tax: float) -> dict:
    return {**item, "total": item["price"] * (1 + tax)}

results = [with_total(it, 0.2) for it in items]
```

Rule: if a function returns `None` and does something, that's a side effect. Isolate such functions at the system boundary (handlers, repositories), and keep the core pure.

## 2. Immutability

Immutable types in Python: `int`, `str`, `bytes`, `tuple`, `frozenset`, `NamedTuple`.

For records in FP style, use **`NamedTuple`** (it's a tuple under the hood, with no `__dict__` and no class behavior):

```python
from typing import NamedTuple

class User(NamedTuple):
    id: int
    name: str
    email: str

u  = User(1, "Alice", "a@x.com")
u2 = u._replace(email="alice@x.com")  # new object, u is untouched
```

If the data has no behavior at all, use a plain `dict` returned from a factory function:

```python
def make_user(id: int, name: str, email: str) -> dict:
    return {"id": id, "name": name, "email": email}

def with_email(user: dict, email: str) -> dict:
    return {**user, "email": email}
```

Read-only view of a dictionary or module constants — via `types.MappingProxyType`:

```python
from types import MappingProxyType

CONFIG = MappingProxyType({"host": "localhost", "port": 5432})
CONFIG["host"] = "x"  # TypeError: 'mappingproxy' does not support item assignment
```

`@dataclass(frozen=True)` is a pragmatic compromise when you need methods, validation in `__post_init__`, or framework integration. In strictly functional code, prefer `NamedTuple` or a dict factory.

For collections, return new ones rather than mutating:

```python
# Bad
def add_tag(tags: list[str], tag: str) -> list[str]:
    tags.append(tag)
    return tags

# Good
def add_tag(tags: tuple[str, ...], tag: str) -> tuple[str, ...]:
    return (*tags, tag)
```

## 3. Higher-order functions

A first-class function: can be passed, returned, and captured in closures.

```python
from functools import partial, reduce
from operator import add, attrgetter, itemgetter

# partial: fix part of the arguments
to_usd = partial(format, fmt="${:.2f}")

# reduce: fold
total = reduce(add, prices, 0)

# operator: atomic operations without lambdas
users.sort(key=attrgetter("created_at"))
rows.sort(key=itemgetter("id"))
```

**Rule**: use `lambda` only for a single short expression inside `key=` / `map` / `filter`. If the body is longer than one line, use a regular `def`.

## 4. Closures and currying

A **closure** is an inner function that captures variables from an outer scope. Useful for configuration and accumulators:

```python
def make_multiplier(factor: int):
    def multiply(x: int) -> int:
        return x * factor
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

From wachawo/claude-skills, MIT.

More from wachawo/claude-skills