Some modification and updateds

.github/workflows/build.yaml

@@ -0,0 +1,76 @@
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+name: Build
+
+jobs:
+  checking:
+    name: Lint & Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.x"
+      - name: Install Dev dependencies
+        run: |
+          echo ${{github.ref}}
+          pip install pytest black mypy pytest-asyncio pytest-cov pytest-black pytest-mypy
+          pip install -e .
+
+      - name: Run Tests
+        run: python setup.py test
+      - uses: codecov/codecov-action@v1
+        with:
+          file: ./reports/coverage.xml 
+          flags: unittests 
+          fail_ci_if_error: true 
+          verbose: true 
+
+  releasing:  
+    name: Build Release
+    runs-on: ubuntu-latest
+    needs: checking
+    if:  github.ref == 'refs/heads/master' 
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.x"
+      - name: Install Dev dependencies
+        run: |
+          pip install black
+      - name: Release
+        id: release
+        uses: rymndhng/release-on-push-action@v0.14.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          bump_version_scheme: patch
+
+      - name: Check Output Parameters
+        run: echo "Got version ${{ steps.release.outputs.tag_name }}"
+      - name: Print Version
+        run: |
+          sed -i '$ d' monads/__init__.py 
+          echo "version='${{ steps.release.outputs.tag_name }}'" >>  monads/__init__.py   
+          sed -i '9s/.*/    version="${{ steps.release.outputs.tag_name }}",/' setup.py 
+          black setup.py 
+          black monads/__init__.py    
+      - uses: mikeal/publish-to-github-action@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+
+

.github/workflows/todo.yaml

@@ -0,0 +1,22 @@
+on:
+  push:
+    branches:
+      - master
+
+name: "TODO to Issue Check"
+
+jobs:
+  build:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: "actions/checkout@master"
+      - name: "TODO to Issue"
+        uses: "alstr/todo-to-issue-action@v1.2-beta"
+        with:
+          REPO: ${{ github.repository }}
+          BEFORE: ${{ github.event.before }}
+          SHA: ${{ github.sha }}
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          LABEL: "# TODO"
+          COMMENT_MARKER: "#"
+        id: "todo"

.gitignore

@@ -109,3 +109,4 @@ venv.bak/
 .mypy_cache/
 .dmypy.json
 dmypy.json
+.vscode

README.md

@@ -1,6 +1,6 @@
 # Type-safe Monads
 
-[![Build Status](https://travis-ci.com/correl/typesafe-monads.svg?branch=master)](https://travis-ci.com/correl/typesafe-monads)
+![Build](https://github.com/correl/typesafe-monads/workflows/Build/badge.svg)
 [![codecov](https://codecov.io/gh/correl/typesafe-monads/branch/master/graph/badge.svg)](https://codecov.io/gh/correl/typesafe-monads)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
 
@@ -18,6 +18,31 @@ lack of type constraints preventing incorrect usage. I could've
 attempted to add type annotations to one of those libraries, but
 building my own is more fun.
 
+This is a fork of the original work by  [Correl Roush](http://correl.phoenixinquis.net/)
+
+I added some utility methods to make it easier to use in my day to day code and better interate with the pythonic style ( ie _List Comprehension_ )
+
+## Installation
+
+There is no *pipy* release  ( yet)
+
+```bash
+$ pip install typesafe-monads
+```
+
+## Curring
+
+Mixing Higher order functions ( functions that return a function ) with moand is a very common programming style other functional programming languages.
+With _curry_ decorator you can transform a function in a _curried_ function: just apss some positional parameters and get back a function with the remaining ones.
+
+```python
+@curry
+def power(exp: int, base: int ) -> int:
+    return math.pow(base, exp)
+
+square_fn = power(2) # a function that returns the square of the parameter
+
+```
 
 ## Base Classes
 
@@ -122,6 +147,9 @@ value if the list is empty.
 
 ## Monads
 
+Wrapped values should be immutable: they are _protected_ from accidental direct writing with *Final* type and the pythonic naming convention.
+
+
 ### Maybe[T]
 
 Represents optional data. A `Maybe` instance of a certain type `T` will
@@ -146,7 +174,13 @@ failure type `E`.
 
 ### List[T]
 
-Represents a sequence of items.
+Represents a ordered sequence of items.
+
+- Also implements `Monoid`.
+
+### Set[T]
+
+Represents a unordered sequence of unique items.
 
 - Also implements `Monoid`.
 
@@ -159,3 +193,29 @@ Represents an asynchronous action.
 ### Reader[T]
 
 Represents the application of a function to it's argument.
+
+## Monads as iterable
+
+It is handy to iterate over some monad contents. *List* is obliviously the first candidate:
+```python
+
+m_list: List[int] = List([1, 2, 4, 9])
+for i in m_list:
+    ...
+
+#Or filter with a generator
+
+evens: List[int] = [k for k in m_list if k % 2 == 0 ]
+
+```
+
+If you want to something to happen just if a *Maybe* monad is defined
+```python
+
+for n in Just("one"):
+  ...
+
+```
+
+The same apply for *Results*
+

monads/__init__.py

@@ -2,7 +2,10 @@
 from .applicative import Applicative
 from .monad import Monad
 from .list import List
+from .set import Set
 from .maybe import Maybe, Just, Nothing
 from .result import Result, Ok, Err
 from .future import Future
 from .reader import Reader
+
+version = "v0.0.15"

monads/applicative.py

@@ -19,4 +19,5 @@ def pure(cls, value: T) -> Applicative[T]:  # pragma: no cover
     def apply(self, functor: Any) -> Functor[S]:  # pragma: no cover
         raise NotImplementedError
 
-    __and__ = lambda other, self: Applicative.apply(self, other)
+    def __and__(self, other: Any) -> Functor[S]:  # pragma: no cover
+        return Applicative.apply(self, other)

monads/future.py

@@ -54,12 +54,15 @@ def mcons(acc: Future[List[T]], x: Awaitable[T]) -> Future[List[T]]:
             future: Future[T] = x if isinstance(x, Future) else Future(x)
             return acc.bind(lambda acc_: future.map(lambda x_: acc_ + [x_]))
 
-        empty: Future[List[T]] = cls.pure([])
+        empty_list: List[T] = []
+        empty: Future[List[T]] = Future.pure(empty_list)
         return functools.reduce(mcons, xs, empty)
 
     def __await__(self):
         return self.awaitable.__await__()
 
     __rshift__ = bind
-    __and__ = lambda other, self: Future.apply(self, other)
+
+    __and__ = lambda other, self: Future.apply(self, other)  # type: ignore
+
     __mul__ = __rmul__ = map

monads/list.py

@@ -1,10 +1,21 @@
 from __future__ import annotations
 from functools import reduce
 from itertools import chain
-from typing import Callable, Iterable, List as _List, TypeVar
+from monads import functor
+from typing import (
+    Callable,
+    Iterable,
+    Iterator,
+    List as _List,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+)
 
 from .monad import Monad
 from .monoid import Monoidal
+from .currying import CurriedBinary, uncurry
 
 T = TypeVar("T")
 S = TypeVar("S")
@@ -16,34 +27,70 @@ def pure(cls, value: T) -> List[T]:
         return List([value])
 
     def bind(self, function: Callable[[T], List[S]]) -> List[S]:
-        return reduce(List.mappend, map(function, self.value), List.mzero())
+        return reduce(List.mappend, map(function, self._value), List.mzero())
 
     def map(self, function: Callable[[T], S]) -> List[S]:
-        return List(list(map(function, self.value)))
+        return List(list(map(function, self._value)))
 
     def apply(self, functor: List[Callable[[T], S]]) -> List[S]:
+
         return List(
-            list(chain.from_iterable([map(f, self.value) for f in functor.value]))
+            list(chain.from_iterable([map(f, self._value) for f in functor._value]))
         )
 
+    @classmethod
+    def mzero(cls) -> List[T]:
+        return cls(list())
+
     @classmethod
     def sequence(cls, xs: Iterable[List[T]]) -> List[_List[T]]:
         """Evaluate monadic actions in sequence, collecting results."""
 
         def mcons(acc: List[_List[T]], x: List[T]) -> List[_List[T]]:
             return acc.bind(lambda acc_: x.map(lambda x_: acc_ + [x_]))
 
-        empty: List[_List[T]] = cls.pure([])
+        empty: List[_List[T]] = List.pure([])
         return reduce(mcons, xs, empty)
 
-    @classmethod
-    def mzero(cls) -> List[T]:
-        return cls(list())
+    def flatten(self) -> List[T]:
+        def flat(acc: List[T], element: T) -> List[T]:
+            if element and isinstance(element, Iterable):
+                for k in element:
+                    acc = acc.mappend(List([k]))
+            elif element:
+                acc = acc.mappend(List([element]))
+            return acc
+
+        return List(reduce(flat, self, List.mzero()))  # type: ignore
+
+    def sort(self, key: Optional[str] = None, reverse: bool = False) -> List[T]:
+        lst_copy = self._value.copy()
+        lst_copy.sort(key=key, reverse=reverse)  # type: ignore
+        return List(lst_copy)
+
+    def fold(
+        self, func: Union[Callable[[S, T], S], CurriedBinary[S, T, S]], base_val: S
+    ) -> S:
+        if isinstance(func, CurriedBinary):
+            functor = uncurry(cast(CurriedBinary, func))
+        else:
+            functor = func
+        return reduce(functor, self._value, base_val)  # type: ignore
+
+    __and__ = lambda other, self: List.apply(self, other)  # type: ignore
 
     def mappend(self, other: List[T]) -> List[T]:
-        return List(self.value + other.value)
+        return List(self._value + other._value)
 
     __add__ = mappend
-    __and__ = lambda other, self: List.apply(self, other)
     __mul__ = __rmul__ = map
     __rshift__ = bind
+
+    def __sizeof__(self) -> int:
+        return self._value.__sizeof__()
+
+    def __len__(self) -> int:
+        return len(list(self._value))
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self._value)