Common LISP-style closures with Python

Discussion in 'Python' started by Antti J Ylikoski, Feb 4, 2012.

  1. In Python textbooks that I have read, it is usually not mentioned that
    we can very easily program Common LISP-style closures with Python. It
    is done as follows:

    -------------------------------------

    # Make a Common LISP-like closure with Python.
    #
    # Antti J Ylikoski 02-03-2012.

    def f1():
    n = 0
    def f2():
    nonlocal n
    n += 1
    return n
    return f2

    -------------------------------------

    and now we can do:

    -------------------------------------

    -------------------------------------

    i. e. we can have several functions with private local states which
    are kept between function calls, in other words we can have Common
    LISP-like closures.

    yours, Antti J Ylikoski
    Helsinki, Finland, the EU
     
    Antti J Ylikoski, Feb 4, 2012
    #1
    1. Advertisements

  2. Antti J Ylikoski

    Chris Rebert Guest

    Out of curiosity, what would be non-Common-Lisp-style closures?

    Cheers,
    Chris
     
    Chris Rebert, Feb 4, 2012
    #2
    1. Advertisements

  3. I understand that a "closure" is something which is typical of
    functional programming languages. -- Scheme-style closures, for example.

    I don't know Haskell, ML etc. but I do suspect that we could create
    closures in those languages as well. Maybe someone more expert than me
    can help?

    regards, Andy
     
    Antti J Ylikoski, Feb 4, 2012
    #3
  4. This is how it is done in standard Common LISP:

    -----------------------------------------

    ;;; Closure with Common LISP.
    ;;;
    ;;; Antti J Ylikoski 02-03-2012.

    (defun mak-1 ()
    (let ((n 0))
    #'(lambda () (incf n))))
     
    Antti J Ylikoski, Feb 4, 2012
    #4
  5. I think what Chris asking is: what is the feature of Common-Lisp
    closures that Python closures share but other languages don't?

    I think what he is implying is that there is no such feature. Python
    closures are no more "Common-Lisp-style" than they are "Scheme-style"
    or "Smalltalk-like" or any other language-like.
     
    Arnaud Delobelle, Feb 4, 2012
    #5
  6. I would say that Python closures are equivalent with Common LISP
    closures (except that LAMBDA is more limited in Python, which is a
    feature which I don't like.)

    Do you maybe mean non-Common-LISP-style closures in Python? I cannot
    think of any ones.

    kind regards, Andy
     
    Antti J Ylikoski, Feb 4, 2012
    #6
  7. Antti J Ylikoski

    Tomasz Rola Guest

    AFAIK there is only one style for closure, similar to one style for
    square.

    There are quite a lot languages implementing closures, and quite a lot try
    to imitate them, including C with non-standard extension (without using
    those imitations I cannot say if they are good enough).

    http://en.wikipedia.org/wiki/Closure_(computer_science)

    Wrt lambdas, I really like blocks from Ruby (which AFAIK stem from blocks
    in Smalltalk, not sure if they call them "blocks").

    http://lesscode.org/2005/07/12/ruby-colored-blocks-in-python/

    http://railsguru.org/2010/03/learn-ruby-procs-blocks-lambda/

    I mean, myself I am ok with lambdas (using them in languages where lambda
    is welcomed and contributing citizen) but blocks in place of lambdas would
    be nice to have in Python. Introduction of "with" construct was good IMHO,
    but if one likes coding style relying on passing anonymous pieces of code
    then Python might not be good choice for this.

    On the other hand, one can argue that using anonymous code too much is not
    the best style. I am not sure if extensive use of blocks/lambdas really
    helps, or if it contributes to "clever" hacks and a source of maintainance
    pain. So, perhaps it is good to have it in a few different ways -
    like, Ruby, Python and CL - and experiment with them all.

    In other words, rather than talking about making Python more like some
    other language(s) I think it is much better to learn those other
    language(s). If you'd like to try "unlimited" lambda, you might want to
    play with Racket, a Scheme superset. Or any other Scheme - it's simple
    enough to start coding after a day or two of learning (I mean Fibonaccis
    and Erastotenes sieves, not implementing database or web server).

    Myself, I would rather have blocks/lambdas and not need them rather than
    the other way, but that's just me.

    Regards,
    Tomasz Rola

    --
    ** A C programmer asked whether computer had Buddha's nature. **
    ** As the answer, master did "rm -rif" on the programmer's home **
    ** directory. And then the C programmer became enlightened... **
    ** **
    ** Tomasz Rola mailto: **
     
    Tomasz Rola, Feb 4, 2012
    #7
  8. "No such feature"? What's that nonlocal thing then? The above function
    could not be written that way in Python 2.

    Of course maybe we want to put this feature in another category, but
    anyway, the function couldn't be written in some languages, even
    though they have closures.

    -- Devin
     
    Devin Jeanpierre, Feb 4, 2012
    #8
  9. Antti J Ylikoski

    John O'Hagan Guest

    On Sat, 04 Feb 2012 02:27:56 +0200

    [...]

    I'm not sure how naughty this is, but the same thing can be done without using
    nonlocal by storing the local state as an attribute of the enclosed function
    object:
    .... def g():
    .... g.count += 1
    .... return g.count
    .... g.count = 0
    .... return g
    ....3

    This way, you can also write to the attribute:
    1


    John
     
    John O'Hagan, Feb 5, 2012
    #9
  10. Yes, I do know that, but then it would not be a closure :)))))))))

    Andy
     
    Antti J Ylikoski, Feb 5, 2012
    #10
  11. Antti J Ylikoski

    Ian Kelly Guest

    Sure it is. Where do you think it looks up the function object?

    Cheers,
    Ian
     
    Ian Kelly, Feb 5, 2012
    #11
  12. Antti J Ylikoski

    Rick Johnson Guest

    do my eyes not see nor my ears not hear?
    a thread about common Lisp and Xan Lee is not near?
    would someone please him wake up and tell him all about,
    the thread titled "Common LISP-style closures with Python"
    and that he has been left out!
     
    Rick Johnson, Feb 5, 2012
    #12
  13. OK, thank you for correcting me.

    Andy
     
    Antti J Ylikoski, Feb 6, 2012
    #13
  14. Antti J Ylikoski

    John Nagle Guest

    Most dynamic languages have closures. Even Perl and Javascript
    have closures. Javascript really needs them, because the "callback"
    orientation of Javascript means you often need to package up state
    and pass it into a callback. It really has very little to do with
    functional programming.

    If you want to see a different style of closure, check out Rust,
    Mozilla's new language. Rust doesn't have the "spaghetti stack"
    needed to implement closures, so it has more limited closure
    semantics. It's more like some of the C add-ons for closures,
    but sounder.

    John Nagle
     
    John Nagle, Feb 10, 2012
    #14
  15. 在 2012å¹´2月4日星期六UTC+8上åˆ8æ—¶27分56秒,Antti J Ylikoski写é“:
    We are not in the 1990's now. A descent CAD or internet application now should be able to support users with at least one or more script
    languages easily. Whether it's javascript or java or flash in the browser-based applications, or go, python in the google desktop API,
    commercial SW applications to be able to evolve in the long run are not jobs from the publishers and the original writers of the SW packages only.

    I don't want to include a big fat compiler in my software,
    what else can I do ?

    LISP is too fat, too.
     
    88888 Dihedral, Feb 10, 2012
    #15
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.