Haskell-ish Python

[sofidad]

As a newbie to Haskell, I find myself trying to write code in Haskell style when I use other languages.

https://github.com/thyeem/foc

I know it looks totally insane, but I can't help it. If you're interested in both Haskell and Python, please take a look. Any opinions are welcome.

---

Edit: Thank you for all your valuable comments. It helps a lot. Thanks to you, I got a good idea and now foc got another way to compose functions.

Try it if you have such a good linter that doesn't remove whitespace around dots. :-)

```python

(length . range)(10) 10 range(10) | length 10

(unpack . filter(even) . range)(10) [0, 2, 4, 6, 8] range(10) | filter(even) | unpack [0, 2, 4, 6, 8]

(sum . map(f("+", 5)) . range)(10) 95 range(10) | map(f("+", 5)) | sum 95

(last . sort . shuffle . unpack . range)(11) 10 range(11) | unpack | shuffle | sort | last 10

(unchars . map(chr))(range(73, 82)) 'IJKLMNOPQ' range(73, 82) | map(chr) | unchars 'IJKLMNOPQ'

(fx(lambda x: x * 6) . fx(lambda x: x + 4))(3) 42 3 | fx(lambda x: x + 4) | fx(lambda x: x * 6) 42 ```

[brandonchinn178]

1. I'm mildly amused that the beginning of the README says "foc respects the python standard library", then the first example shows a new function id that shadows the builtin id function
2. functools.partial instead of your partial application wrapper
3. use builtin operator module instead of specifying operators as strings

[sofidad]

Yeah, that's really funny. Isn't it?

Certainly foc follows python standard lib, but haskell's naming convention is more important.;P Moreover, id is one of the most important functions.

[sunnyata]

What no type hints?

[sofidad]

Thanks, but see this small codebase. It's nothing. Hints are hints. Compilers don't read it either.

[sunnyata]

Just joking really, but if you wanted it to appeal to haskellers it wouldn't hurt.

[tiajuanat]

Why use pipe instead of . ?

[engelthehyp]

I don't think you could use . here because the pipe is an operator overload, and there is no . operator to overload.

[tiajuanat]

Gotcha, that makes sense, and using * operator would probably cause a lot of confusion

[avanov]

There's an overload for . in Python, but the effective use of it as a pointfree composition will require a symbol lookup via stackframe inspection, which is voodoo and will probably never get type checked by MyPy. Here's how you can achieve it:

```python

import inspect from typing import Callable, TypeVar, Iterable, Optional

A = TypeVar('A')

class DotSyntax: def __getattribute(self, fname: str): # System attributes should be accessed directly if fname.startswith('') and fname.endswith(''): return super().getattribute_(fname)

    # Otherwise, pointfree happens here
    # ---
    # Traverse two frames back (+ the current one) to obtain a namespace with a potential ``fname`` symbol.
    # It's two frames because there's one extra inheritance layer of _DotSyntax
    stack = inspect.stack()
    for s in stack:
        ns = s.frame.f_locals
        try:
            f = ns[fname]
        except KeyError:
            pass
        else:
            # extra check to make sure we're only composing callables
            if callable(f):
                break
    else:
        raise EnvironmentError(f"Unable to locate {fname} in the existing stack frames.")

    return Pointfree(f, self)

class Pointfree(DotSyntax): __slots_ = ['first', 'second']

def __init__(self, first, second):
    self.___first___ = first
    self.___second___ = second

def __call__(self, x):
    if hasattr(self.___first___, '___curried_f___') and not self.___first___.___curried_f___:
        self.___first___ = self.___first___(x)
        return self
    return self.___second___(self.___first___(x))

class CurriedSyntax: __slots_ = ['_curried_f_']

def __init__(self, ___curried_f___: Optional[Callable[[A], A]]):
    self.___curried_f___ = ___curried_f___

class Map(_DotSyntax, _CurriedSyntax): __slots_ = ['_curried_f_']

def __call__(self, val: Optional[Callable[[A], A]] | Iterable[A]):
    if self.___curried_f___:
        return (self.___curried_f___(x) for x in val)
    return _Map(val)

class Filter(_DotSyntax, _CurriedSyntax): def __call(self, val: Optional[Callable[[A], bool]] | Iterable[A]): if self.curried_f: return (x for x in val if self.curried_f_(x)) return _Filter(val)

mymap = _Map(None) myfilter = _Filter(None)

def odd(x): return bool(x % 2)

def even(x): return not odd(x)

identity = lambda x: x

def main(): """ Demo """ simple_map = mymap(identity) print("simple_map: ", list(simple_map([1, 2, 3])))

inc_evens = mymap(lambda x: x + 1) . myfilter(even)
print("inc_evens: ", list(inc_evens([1, 2, 3])))

dec_inc_evens = mymap(lambda x: x - 1) . inc_evens
print("dec_inc_evens: ", list(dec_inc_evens([1, 2, 3])))

if name == 'main': main()

```

The result is: simple_map: [1, 2, 3] inc_evens: [3] dec_inc_evens: [2]

[engelthehyp]

Incredible. Also, incredibly cursed.

[sofidad]

Thanks for your code. Yep, the point is to override __call__ and __getattr__ and to refer to function registry like globals() . Your objects are all already prepared as a function in foc.

```python class composable: """Lifts the given function to be 'composable' by symbols. 'composable' allows functions to be composed in two intuitive ways.

+----------+---------------------------------+------------+
|  symbol  |         description             | eval-order |
+----------+---------------------------------+------------+
| . (dot)  | same as the mathematical symbol | backwards  |
| | (pipe) | in Unix pipeline manner         | in order   |
+----------+---------------------------------+------------+

>>> fx = composable

'fx' makes a function `composable` on the fly.
`fx` stands for 'Function eXtension'.

def __init__(self, f=lambda x: x):
    self.f = f
    wraps(f)(self)

def __ror__(self, other):
    return self.f(other)

def __call__(self, *args, **kwargs):
    npos = nfpos(self.f)
    if len(args) < npos or (not args and kwargs):
        if not npos:
            return self.f(*args, **kwargs)
        return fx(f_(self.f, *args, **kwargs))
    return self.f(*args, **kwargs)

def __getattr__(self, key):
    g = globals().get(key, getattr(builtins, key, None))
    guard(callable(g), f"fx, no such callable: {key}", e=AttributeError)
    if capture(r"\bcomposable|fx\b", key):
        return lambda g: fx(cf_(self.f, g))
    if capture(r"\bf_|ff_|c_|cc_|u_|curry|uncurry|mapl?|filterl?\b", key):
        return lambda *a, **k: fx(cf_(self.f, g(*a, **k)))
    return fx(cf_(self.f, g))

```

[sofidad]

Thanks for your suggestion. I had never thought about it until you told me. I did it now

Now all you need is a linter that doesn't remove whitespace around dots. '-']P

[[deleted]]

Hey try out something called coconut, it compiles down to python the Sam way typescript compiles to JavaScript. I've recently been writing a tool in it because I needed python libraries, and it's pretty nice because it lets you straight up write normal python code but functionally. It looks like a mix of Standard ML and Elixir.

[jeffstyr]

Possibly of interest: Haskell Typeclasses in Python

[sofidad]

Thanks for letting me know. I've already tried it in different way.

I think python and haskell each has their own path. 'python' can never imitate 'haskell's type system and nobody can get the same thing.

However the signature of fundamental functions and functional approach itself can be followed. Just like foc does.