Functors, Applicatives, And Monads in Python
OSlash (Ø) is a library for learning and understanding functional programming in Python 3.12+. It re-implements concepts from Learn You a Haskell for Great Good! using Python with modern type annotations. OSlash unifies functional and object-oriented paradigms by grouping related functions within classes. Most monads store wrapped values or computations on their instances; the immutable linked list stores its elements within function closures.
✨ What's New in 1.0
OSlash 1.0 is a complete modernization for Python 3.12+:
- Modern Type System: Fully type-checked with Pyright in strict mode
- PEP 695 Syntax: Clean type parameters (
class Maybe[T]:instead ofGeneric[T]) - Modern Tooling: Built with uv, formatted with ruff, validated with pre-commit hooks
- Production Status: Stable release ready for educational use
Type Safety: OSlash is fully type-checked with Pyright in strict mode, providing excellent IDE support and catching errors at development time. It leverages Python 3.12's PEP 695 type parameter syntax for clean, ergonomic generic types.
OSlash is intended to be a tutorial. For practical functional programming in Python in production environments you should consider using Expression instead.
Install
# Using pip
pip install oslash
# Or using uv (recommended)
uv add oslash
The project currently contains implementations for:
Protocols
- Functor, for stuff that can be mapped
- Applicative, for callable stuff
- Monoid, for associative stuff
- Monad, for monadic stuff
And Some Monads
- Identity, boxed stuff in its simplest form
- Maybe (Just | Nothing), for optional stuff
- Either (Right | Left), for possible failures
- List, purely functional list of stuff
- IO Action, for impure stuff
- Writer, for logging stuff
- Reader, for callable stuff
- State, for stateful computations of stuff
- Cont, for continuation of stuff
Validation
Validation is an applicative for independent checks. Either stops at the first
Left, while Validation.apply collects errors in argument order. Convert an
Either with Validation.from_either; a Left becomes a singleton OSlash List.
from oslash import Left, List, Validation, or_else
name = Validation.from_either(Left("name is missing"))
age = Validation.from_either(Left("age is invalid"))
result = Validation.pure(lambda name, age: (name, age)).apply(name).apply(age)
assert result.to_either() == Left(List(["name is missing", "age is invalid"]))
Use or_else(first, fallback) for a choice between two Either results. It
keeps the first Right; if that fails, it returns the fallback, including its
error when both fail. Both arguments are evaluated before the call.
Typing
The concrete classes keep the wrapped result type through map, bind, and apply.
The structural protocols describe a particular operation and its result container:
from collections.abc import Callable
from oslash import Identity
from oslash.typing import Applicative, Functor, Monad
functor: Functor[int, str, Identity[str]] = Identity(1)
mapped: Identity[str] = functor.map(str)
monad: Monad[int, Identity[str]] = Identity(1)
result: Identity[str] = monad.bind(lambda value: Identity(str(value)))
fn: Callable[[int], str] = str
applicative: Applicative[Callable[[int], str], Identity[int], Identity[str]] = Identity(fn)
applied: Identity[str] = applicative.apply(Identity(1))
Monad now takes the input value type and the concrete bind result type.
Applicative takes the wrapped function type, argument container type, and result container type.
Functor[T, U, Result] takes the input value type, mapped value type, and output container type.
This replaces the previous Functor[T] protocol, which only supported same-type mappings.
Writer.map maps the value and keeps its log. Use Writer.map_with_log to transform both.
Writer.unit(value) uses a string log; for another log type, pass empty_log or use Writer.create.
Factories expose WriterFactory[Log]: their unit(value) always uses the configured log identity
and does not accept empty_log. For example, Writer.create("IntWriter", int).unit(1) returns
Writer[int, int]. Annotate instances as Writer[T, Log], rather than using a dynamic factory
name such as StringWriter as a type. Import WriterFactory from oslash.writer when needed.
apply has typed overloads for unary and two-argument functions; applying the first argument of a
two-argument function returns a wrapped one-argument function.
Monadic functions
- >>, for sequencing monadic actions
- compose, for composing monadic functions
Utility functions
- compose, for composing 0 to n functions
But why?
Yes, I know there are other projects out there like PyMonad, fn.py. I'm simply doing this in order to better understand the book. It's so much easier to learn when you implement things yourself. The code may be similar to PyMonad in structure, but is quite different in implementation.
Why is the project called OSlash? OSlash is the Norwegian character called Oslash. Initially I wanted to create a project that used Ø and ø (unicode) for the project name and modules. It didn't work out well, so I renamed it to OSlash.
Examples
Haskell:
> fmap (+3) (Just 2)
Just 5
> (+3) <$> (Just 2)
Just 5
Python:
>>> Just(2).map(lambda x: x+3)
Just 5
>>> (lambda x: x+3) % Just(2)
Just 5
IO Actions:
from oslash import put_line, get_line
main = put_line("What is your name?") | (lambda _:
get_line() | (lambda name:
put_line("What is your age?") | (lambda _:
get_line() | (lambda age:
put_line("Hello " + name + "!") | (lambda _:
put_line("You are " + age + " years old"))))))
if __name__ == "__main__":
main()
Tutorials
- Functors, Applicatives, And Monads In Pictures in Python.
- Three Useful Monads (in progress)
- Using Either monad in Python
Metadata
Release files for oslash 3.0.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| oslash-3.0.0.tar.gz | 68.4 kB | Without provenance | Details for oslash-3.0.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| oslash-3.0.0-py3-none-any.whl | Python 3 | none | any | Details for oslash-3.0.0-py3-none-any.whl |
Total release size: 103.7 kB
Release files / oslash-3.0.0.tar.gz
| Download URL | oslash-3.0.0.tar.gz |
|---|---|
| Size | 68.4 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
01fbb331f9a603ece054d1a662dbb60b4928f72ebcc2dc98518fde7a063fa4cc
|
|
BLAKE2b-256 checksum How to use checksums |
8bc4124cc13a8298001a184e7e1ccb675f2b3adaaa3ac69deeaeed612b2cecdd
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Release files / oslash-3.0.0-py3-none-any.whl
| Download URL | oslash-3.0.0-py3-none-any.whl |
|---|---|
| Size | 35.3 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
4cfdc581f272b6da2c8165a264a30dcfa1c20660493e56f24c98a91119e78a6a
|
|
BLAKE2b-256 checksum How to use checksums |
89064c7eea6b6a22efc94d7543d4337c375512937e71ec548ec3dba87f19827e
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Security for oslash 3.0.0
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.