Functional Python Made Easy

http://hackflow.com/blog/2013/10/13/functional-python-made-easy/

by Suor • 13 years ago

138 32 13 years ago

hackflow.com

houshuang• 13 years ago

Very neat, and great examples. I do a lot of data manipulation myself, and could see this being very helpful/useful.

jnazario• 13 years ago

neat, i do a lot of FP idioms in my code.

another option i frequently borrow from is google's "goopy": http://goog-goopy.sourceforge.net/goopy.functional.html

neur0mancer• 13 years ago

What Python really needs to be more useful as a "functional language" is a consistent way to define algebraic data types and to perform pattern matching.

This is the closest thing i found for that: https://github.com/lihaoyi/macropy

profquail5• 13 years ago

Forgive me if this is a silly question -- I'm an F# developer by trade, and I only know a bit of Python -- but why would you rather add a bunch of features common to strongly+statically-typed functional programming languages to Python instead of simply writing your code in a language which already has support for such features?

For example, you could write code you want to use GADTs and pattern-matching for in Haskell, then create a Python wrapper for scripting purposes. I understand that having your solution written in two languages generally requires more effort to keep things working, and it's more difficult to find qualified developers to hire. To me, it just seems like it would make more sense to use each language's strengths where you need them instead of trying to graft all the features you could ever want into a single language (which, IMO, is basically what C++ does, to it's detriment).

phaer• 13 years ago

Maybe because you want to keep your code base consistent, maybe because there lots of libraries and wrappers in python, maybe because you can run python on nearly all platforms including the jvm, etc.

danneu• 13 years ago

Because it's just a library.

I don't think it's as easy or prudent to hop between languages as you make it out to be. To turn it around, if you can extend your language with features, why would you introduce a whole new language dependency into your project if you don't have to?

lucian19004• 13 years ago

Because for many of us F# and Haskell are not necessarily realistic options. Python runs in a lot more environments and it's still lacking a few (most importantly browsers).

Python is comfortable. I'd very much like a nice statically typed functional language, but that's neither F# nor Haskell. Clojure(script) + Typed Clojure is about the closest practical thing.

goostavos• 13 years ago

My main reason is that I don't write Scala or Haskell professionally. However, I do maintain Python at work. So, while dropping Python and switching to a functional language is not an option, importing a simple library is.

Programming "functionally" in python was one of the best changes I made to my coding practices (it certainly makes dealing with multiprocessing a lot easier!).

nnq• 13 years ago

F# developer by trade

I thought F# was quite a niche language and there weren't any "F# developers", just .NET/C# that also know some F#. How did you end up on this career path?

About grafting features onto Python: most Python guys come from the Linux land and have quite a problem with using a .NET/Mono language, and Haskell is/seems too intimidating and complex. Most also seem to dislike/fear the JVM. So there's only OCaml left and this is even more of a "niche language" than F#. Only viable option is extending Python, unfortunately Python is such a pain in the ass to properly extend so people just make libraries to "ease the pain".

brandonbloom• 13 years ago

I can see the argument for pattern matching, but algebraic data types seem entirely out of place. The primary benefit would be type checking and exhaustivity checks: neither of which fit with the dynamic nature of Python.

Functional != Strongly Typed

tel• 13 years ago

The regularity of ADTs is nice, too, though tagged unions feel weird in dynamic languages.

dchichkov• 13 years ago

Argument matching has been discussed, there've been PEPs on that, and they couldn't come up with a satisfactory syntax. And that whatever you try, 'if/elif' statements are just more readable and streamlined than any syntax they've try to come up with.

As to strongly typed. Has anyone considered a strict attribute in python, I wonder? Because I'd love [1] to have compile time type checks for types/variables that I'm worried about.

[1] certainly not at a cost of having to contend with type hierarchies of a strongly typed language.

jevinskie• 13 years ago

I really like how re_find gives you the actual regex match right off the bat, instead of having to go through match_result.groups()!

falcolas2• 13 years ago

Using groups lets you pull out parts of a match more easily. Perhaps it's a bit of a corner case, but for parsing logs, I find it invaluable.

Suor2• 13 years ago

re_find returns tuple of all captures if there are more than one. See parse ini example

bcl• 13 years ago

This is also helpful - http://docs.python.org/2.7/howto/functional.html

iamartnez• 13 years ago

Guido brought up Python functional programming during the 2012 PyCon keynote: http://www.youtube.com/watch?v=EBRMq2Ioxsc#t=44m25s

joshz• 13 years ago

btw, Python 3.3 introduced ChainMap for "merging" dicts.

http://docs.python.org/dev/library/collections#collections.C...

Functional Python Made Easy

Related Stories