Metadata-Version: 2.1
Name: monad-do
Version: 0.1.0
Summary: Do notation in Python
Home-page: https://github.com/TRCYX/py_monad_do
Author: TRCYX
License: MIT
Keywords: monad
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Topic :: Education
Classifier: Topic :: Software Development :: Libraries
Description-Content-Type: text/markdown
Requires-Dist: fastcache

# py_monad_do

A simple monad do notation implementation with nice syntax using generators. Also includes sample monads such as `Maybe` and `List`.

Sample code:

```python
from monad_do import *

@do(List)
def test_list(a, b):
    x = yield [a * 10, a] # Native lists are coerced into monad Lists here.
    y = yield [b * 100, b * 10, b]
    return [x + y]


print(test_list(3, 4)) # List([430, 70, 34, 403, 43, 7])
```

Monad instances derive from the `Monad` class and provide the methods `pure`(static) and `bind`. The `do` decorators binds the values yielded from a generator to its later computation.

Note that generators are uncopyable, so if some code needs to be run more than once (such as the case for the `List` monad), the generator is run from the beginning once again, with the values to send into it recorded to eliminate duplicate computation. This requires that the generators decorated by `do` to be more or less "pure".

The `do` decorator is implemented inside `monad_do.do_cached`. There is also a simpler implementation in `monad_do.do_simple` which sketches the basic idea, but runs the generator from the beginning for each `yield`.

The implementation is primarily inspired by these following materials:
- [Monads and Do-Blocks in Python](https://blog.bede.io/do-notation-for-monads-in-python/) implements a do notation for the `List` monad through recording sent values.
- [Monads in Python (with nice syntax!)](http://www.valuedlessons.com/2008/01/monads-in-python-with-nice-syntax.html) also implements a similar do notation which universally handle monads that only run the generator once.
- [The Mother of all Monads](https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/the-mother-of-all-monads) gives the idea of implementing other monads through the `Cont` monad.


