wadler_skill

Overview

This skill teaches how to write functional Python code in the spirit of Philip Wadler, emphasizing monadic composition, type-driven design, and algebraic reasoning. It focuses on translating Wadler’s principles—types as propositions, monads as structure, and parametricity—into practical patterns for Python. Use it to design composable abstractions and reason about effects clearly.

How this skill works

The skill inspects problem types first, then suggests implementations that follow monadic, functor, and applicative patterns adapted to Python (e.g., Maybe/Option, Either/Result, State, IO-like wrappers). It proposes compositions using bind/map-like helpers, simple transformer-like stacks, and refactorings that convert ad-hoc effects into explicit, testable abstractions. It highlights laws and free-theorem consequences you can use to validate implementations.

When to use it

• Designing composable effectful APIs in Python
• Refactoring code that mixes errors, state, and I/O into structured abstractions
• Writing library code where type-driven guarantees matter
• Teaching or documenting functional patterns for a Python team
• Validating correctness using algebraic laws and parametricity

Best practices

• Start from the type signature or protocol before writing implementation
• Model effects explicitly with small monadic wrappers (Maybe/Result/State) rather than using exceptions or globals
• Keep functions small and composable; prefer point-free or combinator style where it improves clarity
• Document and rely on monad/applicative/functor laws when proving behavior or designing tests
• Prefer parametric polymorphism (duck-type protocols or generics) to reduce implementation assumptions

Example use cases

• Implement a safe parsing pipeline using Maybe/Result types instead of exceptions
• Compose async, logging, and state effects via lightweight transformer patterns
• Derive traversal functions (e.g., traverse, sequence) from types and reuse across containers
• Refactor callback-heavy code into chained bind/map combinators for readability
• Design a domain API where invariants are enforced by types and algebraic laws