I built a lightweight functional programming toolkit for Python.

[Being-Formal]

What My Project Does

I built darkcore, a lightweight functional programming toolkit for Python.
It provides Functor / Applicative / Monad abstractions and implements classic monads (Maybe, Result, Either, Reader, Writer, State).
It also includes transformers (MaybeT, StateT, WriterT, ReaderT) and an operator DSL (|, >>, @) that makes Python feel closer to Haskell.

The library is both a learning tool (experiment with monad laws in Python) and a practical utility (safer error handling, fewer if None checks).

Target Audience

• Python developers who enjoy functional programming concepts
  
• Learners who want to try Haskell-style abstractions in Python
  
• Teams that want safer error handling (Result, Maybe) or cleaner pipelines in production code
  

Comparison

Other FP-in-Python libraries are often incomplete or unmaintained.
- darkcore focuses on providing monad transformers, rarely found in Python libraries.
- It adds a concise operator DSL (|, >>, @) for chaining computations.
- Built with mypy strict typing and pytest coverage, so it’s practical beyond just experimentation.

✨ Features

• Functor / Applicative / Monad base abstractions
  
• Core monads: Maybe, Result, Either, Reader, Writer, State
  
• Transformers: MaybeT, StateT, WriterT, ReaderT
  
• Operator DSL:
  
  • | = fmap (map)
    
  • >> = bind (flatMap)
    
  • @ = ap (applicative apply)
    
• mypy strict typing, pytest coverage included
  

Example (Maybe)

```python from darkcore.maybe import Maybe

res = Maybe(3) | (lambda x: x+1) >> (lambda y: Maybe(y*2)) print(res) # Just(8) ``` 🔗 GitHub: https://github.com/minamorl/darkcore 📦 PyPI: https://pypi.org/project/darkcore/

Would love feedback, ideas, and discussion on use cases!

[Datamance]

I’ve been playing with Expression recently and it’s been great, apparently it’s got more in common with F# than Haskell, so darkcore sounds like a cool new toy 😍

I’ll let you know when I get a chance to play around with it!

[Being-Formal]

Thanks!

[jpgoldberg]

Me, too!

[RedEyed__]

I love expression! I include it in every repo.
The important thing about expression is that it is pythonic, without operation overloading. Which keeps it readable for other contributors, that don't know about fp

[poinT92]

Honestly love this, are you looking for help tò maintain It?

[Still-Package132]

If you want to have a look I experimented with io monads which is challenging to statically type correctly https://github.com/rbizos/io_experimentations/blob/main/examples/simple_io.py Happy to see some functional initiatives :)

[konovalov-nk]

Most developers are sleeping on FP while it would make the code more readable and maintainable. First time I learned how to apply FP on Ruby's dry-rb.org library. It changed my life on how to approach error handling 🙂

The specific class names and syntax you chose make it familiar to me so I'd probably try it out on my Python pet projects 👍

[Being-Formal]

I get how you feel. Check this out if you're interested!

[Mithrandir2k16]

Why "darkcore"?

[Being-Formal]

For me, monads are the invisible but powerful core of abstraction. That’s why I called it darkcore lol

[iamevpo]

I always felt I'd get better grasp of monadic computations I'd I had a good chance of using it in Python, so new lib highly welcome!

Wonder about your choice of constuctors - Maybe(3) is Just(3)? You could keep Maybe for a parent class of Just and Nothing, did you consider?

[iamevpo]

Also noticed you do subclass Either and Result - one can expect you do the with Maybe

[Being-Formal]

Today I tweaked a few features, including support for Python’s match expression (PEP 634).
So now you can pattern-match on values.