I really don't understand what the purpose of closures is. It seems to me that everything that can be written using closures, is just as easily written without. For example:
Closures can be seen as a form of runtime linking. You can create different functions that each have the same code, but refer to different values (for instance functions) that are lexically visible outside of the function body.
Without closures, functions can usually only refer to global variables and functions.
Name:
Anonymous2012-02-29 13:29
>>4
Wow that's a strange explanation but it's also a good one.
With closures, high order procedures can be used to create objects with their own changeable state and identity.
(define ((person name age sex) msg)
(cond ((eq? msg 'speak)
(list "hello, my name is" name "and I'm a" age sex))
((eq? msg 'birthday)
(set! age (+ age 1))
(list "yay! it's my mother fucking birthday and I'm"
age
"mother fucking years old! fuck yeah!"))
(else (list "I don't understand your command"))))
]=> (define boy (person 'Joe 19 'male))
boy
]=> (define girl (person 'Jane 21 'trap))
girl
]=> (boy 'speak)
(hello, my name is Joe and I'm a 19 male)
]=> (girl 'speak)
(hello, my name is Jane and I'm a 21 trap)
]=> (boy 'birthday)
(yay! it's my mother fucking birthday and I'm 20 mother fucking years old! fuck yeah!)
]=> (boy 'speak)
(hello, my name is Joe and I'm a 20 male)
]=> (girl 'speak)
(hello, my name is Jane and I'm a 21 trap)
Read SICP.
Name:
Anonymous2012-02-29 18:19
>>6
not a lisp user but how would you go about finding joe or jane then seeing as boy and girl are not lists or arrays?
Name:
Anonymous2012-02-29 19:32
>>6
Listen to >>7. This is what's wrong with LISP.
Name:
Anonymous2012-02-29 21:04
Check the man pages for ftw. It's more of an argument for lambdas, but you suppose you wanted to do a file search for user-supplied names. You can't write a function for each one because you don't know until runtime. You could write a replacement for ftw that takes an additional parameter which it will supply to fn (this is common) or use a global (this is stupid.)
If you aren't using a posix system, try reading along with qsort. It takes a comparator. Suppose you had a parametric comparator—same deal.
Or you could use a closure in place of fn (oh but not in C, sorry.)
Non-enclosing lambdas are more common in my experience, such as arguments to map/fold/reduce/filter. Try learning a language besides C, Python or C++/Java (C++ and Java are getting closures though) and you'll probably see it immediately. If you still don't see it, try using JQuery—that'll learn you.
Name:
Anonymous2012-02-29 22:08
>>7-8
But that has nothing to do with the demonstration in >>7...
Name:
Anonymous2012-02-29 23:38
Apple felt that lambdas were so useful they should be added to C.
>>1
Closures are not so much a gimmick meant to fix something in particular like what the scripting languages introduce every month, it is a fundamental building block in some languages like Scheme, and thats pretty much it. Non-functional languages getting closures is a side effect of closures having extra flexibility over the original procedure definition mechanism of that language.
It seems to me that everything that can be written using closures, is just as easily written without.
For a function that maps data with a single closure, a for loop would be easier. But what about a function that maps data over several closures, sometimes with one, sometimes the other, one closure returns a number n, and the mapping function invokes Nth function for that element. Its useful to have the flexibility.
Or at least defining the function outside of main()
Lexical scope is where closures get its power, needleTest cannot access needle if its outside main(). If you passed needle as an extra argument, you lose the interfaceability with find().
You can also think of first order functions and closures as a class that only have one implicit method (call) and a constructor, which is the procedure literal expression.
The constructor is implicit in the code itself. It takes the variable names in lexical scope that are visible when the function literal is evaluated and makes the necessary ones part of the closure (the name describes this). What variables are those? Local variables and arguments, as well as any name outside the enclosing function (in case it also is a closure). This implies that when a procedure returns, any closure that was created might refer to local variables that are about to be popped. Either don't pop (like chicken scheme) or (more commonly) allocate the values that might be part of a closure on the heap.
>>28
I think it's because humans have generally used base 10 as a counting system (though there are some notable exceptions), due to the fact that they have 10 fingers. It makes sense, then, that any programming language designed by humans will use base ten. There is, however, notational support in D for base 2, base 8, and base 16 numbers.