News for hackers. Stuff that matters.
Re:Functional Programming in Python [pdf] by agentultra on Friday July 24, 2015 @06:23PM (#9945580)
Nice, short little book!

`compose` can be simpler:

    def compose(fn, *fns):
        def _composer(f, g):
            return lambda *args: f(g(*args))

        return reduce(_composer, fns, fn)
This little function is really, really cool because it allows you to build up more interesting functions by piecing together a bunch of small, useful ones.

    def upper(s):
        return s.upper()

    def exclaim(s):
        return s + '!'

    # instead of this
    really_angry = lambda s: exclaim(exclaim(upper(s)))
    really_angry('napster bad') # NAPSTER BAD!!

    # we can do this
    really_angry = compose(upper, exclaim, exclaim)
    really_angry('fire good') # FIRE GOOD!!

    # and
    import operator as op
    from functools import partial as p
    max(map(compose(p(op.add, 1), p(op.mul, 3)), (1, 2, 3, 4)))
`compose` is a neat function and worth exploring. This is a cool book and I always hope Python gets more light shone on its FP-friendly features.
Re:Functional Programming in Python [pdf] by architech on Sunday July 26, 2015 @05:11PM (#9952209)
I started with something like that when I was missing function composition in Python. Eventually I ended up with a library [1] including a bunch of other stuff for getting rid of some of the duct tape code you usually need when you just want to compose some functions.

  from pipetools import pipe, X, foreach

  really_angry = pipe | upper | exclaim | exclaim
or...

  really_angry = X.upper() | "{0}!" | "{0}!"


  (1, 2, 3, 4) > foreach((X + 1) | (X * 3)) | max 

You can write some pretty neat looking concise code with this, but also may regret it later when it comes to debugging, especially when lazy evaluation is involved (which is usually the case). The stacktraces tend to be not so helpful...

[1] https://0101.github.io/pipetools/

Re:Functional Programming in Python [pdf] by hajile on Friday July 24, 2015 @07:38PM (#9945882)
For compose to really shine, you need to be able to curry/partially apply functions. This part of things is made much more difficult than necessary because of Python's unnecessarily neutered lambda syntax (in fact, I don't think one can claim that Python is FP friendly until this decision is corrected).

It's also worth noting that reduce() was removed as a builtin for Python 3.

Re:Functional Programming in Python [pdf] by nine_k on Friday July 24, 2015 @08:56PM (#9946135)
I'd love let-like syntax in lambdas, something along the lines of

    lambda x: f(y) + g(y) for y = expensive_computation(x)
In Python 3, `reduce` can be trivially imported from `functools`.
Re:Functional Programming in Python [pdf] by gamegoblin on Saturday July 25, 2015 @01:31AM (#9946670)
The ugly hack around this would be

    lambda x: (lambda y: f(y) + g(y))(expensive_computation(x))
Re:Functional Programming in Python [pdf] by gamegoblin on Saturday July 25, 2015 @01:29AM (#9946663)
It's possible to hack currying into python with a decorator like:

https://gist.github.com/grantslatton/9221084

(I made this for fun, use at your own risk)