commit some functional code

CanftIn · CanftIn · commit 3077f53669d2 · 2020-08-24T21:46:04.000+08:00
diff --git a/functional/func_tools.py b/functional/func_tools.py
@@ -0,0 +1,52 @@
+import inspect
+import operator
+from functools import reduce, partial
+
+def identity(x):
+    return x
+
+def apply(*func_and_args, **kwargs):
+    if not func_and_args:
+        raise TypeError('function argument is required.')
+    func, args = func_and_args[0], func_and_args[1:]
+    return func(*args, **kwargs)
+
+def thread_first(val, *forms):
+    def evalform_front(val, form):
+        if callable(form):
+            return form(val)
+        if isinstance(form, tuple):
+            func, args = form[0], form[1:]
+            args = (val,) + args
+            return func(*args)
+    return reduce(evalform_back, forms, val)
+
+class curry(object):
+    def __init__(self, *args, **kwargs):
+        if not args:
+            raise TypeError('__init__() takes at least 2 arguments (1 given)')
+        func, args = args[0], args[1:]
+        if not callable(func):
+            raise TypeError("Input must be callable")
+
+        if (
+            hasattr(func, 'func')
+            and hasattr(func, 'args')
+            and hasattr(func, 'keywords')
+            and isinstance(func.args, tuple)
+        ):
+            _kwargs = {}
+            if func.keywords:
+                _kwargs.update(func.keywords)
+            _kwargs.update(kwargs)
+            kwargs = _kwargs
+            args = func.args + args
+            func = func.func
+        
+        if kwargs:
+            self._partial = partial(func, *args, **kwargs)
+        else:
+            self._partial = partial(func, *args)
+
+
+
diff --git a/pymonad/monad.py b/pymonad/monad.py
@@ -0,0 +1,49 @@
+from typing import Callable, Generic, TypeVar, Union
+
+S = TypeVar('S')
+T = TypeVar('T')
+
+class Monad(Generic[T]):
+    def __init__(self, value, monoid):
+        self.value = value
+        self.monoid = monoid
+
+    @classmethod
+    def apply(cls, function):
+        class _Application(cls):
+            amap = cls.amap
+            bind = cls.bind
+            insert = cls.insert
+            map = cls.map
+            @staticmethod
+            def to_arguments(*args):
+                results = cls.insert(function)
+                for arg in args:
+                    results = result.amap(arg)
+                return cls(result.value, result.monoid)
+        return _Application(None, None)
+    
+    @classmethod
+    def insert(cls, value: T) -> 'Monad[T]':
+        raise NotImplementedError
+
+    def amap(self: 'Monad[Callable[[S], T]]', monad_value: 'Monad[S]') -> 'Monad[T]':
+        return monad_value.map(self.value)
+
+    def bind(self: 'Monad[S]', kleisli_function: Callable[[S], 'Monad[T]']) -> 'Monad[T]':
+        raise NotImplementedError
+
+    def map(self: 'Monad[S]', function: Callable[[S], T]) -> 'Monad[T]':
+        raise NotImplementedError("'fmap' not defined.")
+
+    def then(
+        self: 'Monad[S]', function: Union[Callable[[S], T], Callable[[S], 'Monad[T]']]
+    ) -> 'Monad[T]':
+        try:
+            result = self.bind(function)
+            if isinstance(result, Monad):
+                return result
+            else:
+                return self.map(function)
+        except AttributeError:
+            return self.map(function)
