
Toolz: A functional standard library for Python - Lofkin
https://github.com/pytoolz/toolz
======
boothead
I love libraries like this and fn.py, and I really miss the things I've got
used to having available in Haskell when I write python. It's possible to use
function patterns in python (Applicative and Functor are things you can
implement in any language). However given who is in charge of python and the
way he feels about FP, I don't think python will ever be a decent functional
programming environment:

    
    
      As long as I'm "in charge" the chances of this (or anything like it) being accepted into
      Python are zero. I get a headache when I try to understand code that uses function
      composition,  and I end up having to laboriously rewrite it using more traditional
      call notation before I move on to understanding what it actually does. Python is not
      Haskell, and perhaps more importantly, Python users are not like Haskell users.
      Either way, what may work out beautifully in Haskell will be like a
      fish out of water in Python.
    
      I understand that it's fun to try to sole this puzzle, but evolving Python is more than
      solving puzzles. Enjoy debating the puzzle, but in the end Python will survive
      without the solution.
    

[http://stackoverflow.com/questions/1017621/why-isnt-
python-v...](http://stackoverflow.com/questions/1017621/why-isnt-python-very-
good-for-functional-programming)

~~~
amirouche
It seems to me function composition does similar thing as inheritance. I don't
know about other (more higher?) functionnal patterns.

Side note: I already had to write or copy/paste most of the function of
pytoolz already once at least.

~~~
agumonkey
Inheritance is quite heavy and static. FP idioms are full of tiny combinators
to assemble pieces of logic to suit your needs, flip/reorder parameters,
"cache" them through partial application. The historical reusable code that
OOP claimed through the 90s seems much more real using FP. OOP is too verbose
and too name-friendly, people create lots of classes not abstract enough to be
used anywhere else, closer to concrete types than abstractions.

------
jboynyc
Between this an fn.py
([https://github.com/kachayev/fn.py](https://github.com/kachayev/fn.py)),
functional programming in Python has really good library support beyond the
standard library.

~~~
kmike84
[https://github.com/Suor/funcy](https://github.com/Suor/funcy) is also nice

------
wodenokoto
That is not what stemming is at all. Stemming is going from "running" to
"run", not "run!" to "run"

[http://en.m.wikipedia.org/wiki/Stemming](http://en.m.wikipedia.org/wiki/Stemming)

~~~
swasheck
agreed. i'm not sure why one would choose to implement an inadequate function
here over against something like nltk
([http://www.nltk.org/book/](http://www.nltk.org/book/)), which is excellent.

------
pionar
It seems to me that if you want functional programming, you choose a
functional language. You don't (excuse my language) bastardize an OO language
for it.

~~~
rnhmjoj
[https://gist.github.com/rnhmjoj/5ce4a571a624bd42c771](https://gist.github.com/rnhmjoj/5ce4a571a624bd42c771)
I created a bastard.

------
kraymer
Tangential but ... could someone give me the name of the python library that
made the front page last month and that "extends the standard lib" (itertools
recipes, dates helper functions, etc)? Can't find it using HN search. Email in
my profile. thks

~~~
estefan
[https://github.com/mahmoud/boltons](https://github.com/mahmoud/boltons)

[https://news.ycombinator.com/item?id=9350562](https://news.ycombinator.com/item?id=9350562)

------
kmike84
It is sometimes hard to justify a dependency - many of toolz/fn.py/funcy
functions are not hard to write manually.

The great thing about toolz is its
[https://github.com/pytoolz/cytoolz](https://github.com/pytoolz/cytoolz)
counterpart which provides an optimized implementation of toolz. It is useful
when you have a bottleneck in Python code - e.g. run several functions
(functoolz.juxt), merge dictionaries (dicttooz.merge), etc. With cytoolz the
code becomes prettier and faster, not only prettier, so it is easier for
cytoolz to sneak in.

~~~
mrocklin
Interesting. What are your thoughts on the costs of dependencies? What about
toolz makes you hesitate to depend on it?

------
mrocklin
[http://toolz.readthedocs.org/en/latest/](http://toolz.readthedocs.org/en/latest/)

------
nilkn
I love stuff like this, though I feel it makes the code actually harder to
read because none of it's standardized and there are a variety of somewhat
equivalent but not completely isomorphic libraries out there for functional
programming in Python.

------
calebm
Does it have a recursive dictionary merge - something like merge({'a': {'b':
1}}, {'a': {'c': 2}}) -> {'a': {'b': 1, 'c': 2}} ?

~~~
alien_robot
Wish I had known I could compose something from existing functional libs, but
I created this simple function to solve that very problem.
[https://gist.github.com/angstwad/bf22d1822c38a92ec0a9](https://gist.github.com/angstwad/bf22d1822c38a92ec0a9)

------
agumonkey
Year old reddit thread

[http://www.reddit.com/r/Python/comments/1wrlji/](http://www.reddit.com/r/Python/comments/1wrlji/)

------
alvare
I always include toolz in my Python projects. It's also useful as a
compatibility wrapper.

