fmappy

Brings the Functionality of the Functor to Python.

>>> fmap(square, dict(one=1, two=2, three=3))
{'one': 1, 'two': 4, 'three': 9}

I miss this. The implementation of map always returns a generator; but sometimes I want to keep the container type, just map the contained values. This is what the functiona-programming world knows as a Functor.

Why this Library?

>>> numbers = {'one': 1, 'two': 2, 'three': 3}
>>> squared = {k: v*v for k, v in numbers.items()}
>>> names = numbers.keys()
>>> NAMES = tuple(n.upper() for n in names)
>>> NAMES_TOO = tuple(map(str.upper, names))

We have got used to these patterns: dict-comprehensions, using map and storing it into a tuple for later use. So used that we don't realize it is chipping away some of our mental capacity while reading and writing code. I want this to stop: a use case that occurs so often has the right to be streamlined into something simpler, and we can borrow gratefully from the functional programming world here.

A number of libraries exist for full fledged functional programming in Python. These libraries assume an FP background. I want a library that starts from the Python syntax, and adds as little clutter as possible - as many batteries included.

As Alan Kaye said: make Simple things Simple, and Hard things Possible.

I bumped onto this gist and realized this was something: We Already Needed It For A Long Time (WANIFALT). This is simple enough to use for even starting Pythonistas. And it allows enough extensions for the professional to integrate it in their code base.

Goals

• import this
• cover 95% of the day to day use cases (to my knowledge)
• wrist-friendly: use fmap instead of map and you're there
• Closed for Change, Open for Extension

Other Libraries

• https://pypi.org/project/pyfunctor/: almost, but not quite, entirely unlike Python

  f = (Functor(range(10)) >> c_(map)(lambda x: x * 2)

• https://pypi.org/project/tx-functional/: almost like Python

  assert Nothing.map(lambda x:2) == Nothing