closures

I'm new to JS (from C++/etc), and it's just occurred to me that closures seem to be a simpler and more convenient way to handle encapsulation than classes. This code seems to give a simple way to handle encapsulation: function addProperty(o) { var value; o["get"] = function() { return value; } o["set"] = function(v) { value = v; } } // create two independent objects which are instances of pseudo-class 'addProperty', // which each have their own version of a set of local fields, and methods that // operate on those fields: var a = {}; addProperty(a); var b = {}; addProperty(b); If you just want

I have two functions that return a list of functions. The functions take in a number x and add i to it. i is an integer increasing from 0-9. def test_without_closure(): return [lambda x: x+i for i in range(10)] def test_with_yield(): for i in range(10): yield lambda x: x+i I would expect test_without_closure to return a list of 10 functions that each add 9 to x since i 's value is 9 . print sum(t(1) for t in test_without_closure()) # prints 100 I expected that test_with_yield would also have the same behavior, but it correctly creates the 10 functions. print sum(t(1) for t in test_with_yield()

Is there a way, when writing a lambda function within a member function, to capture fields of the enclosing class by value? The default catch-all = doesn't work because when I reference the variable inside the lambda I get instead a dereferencing from the captured this pointer, as well as explicitly naming the variable in the capture list, because I get two compile error: capture of non-variable <name> , and ‘this’ was not captured for this lambda function No, data members cannot be captured by value. A lambda can capture only two kinds of things: the this pointer, and nonstatic local

In Javascript, what's the difference between a namespace and a closure? They seem very similar to me. EDIT Specifically, this article discusses namespaces and closures, and has sentences like Now, we’re still going to have situations where we’ll want to declare variables that don’t naturally fit into a namespaced object structure. But we don’t want those variables to have a global scope. This is where self-invoking functions come in. It goes on to give what looks a lot like a closure, as an "object namespace". It looks to me like the namespace IS a closure ...but maybe it's not...? Help? A

If a variable is not available in a function when it's needed, then it's being looked for in the scope chain (which is a closure), but other times it's being searched for in the prototype chain. I am trying to wrap my head around which is happening when. I was wondering if someone could kindly clear the mist for me, or refer me to some literature discussing this topic specifically. For example, would I be right saying that: - Objects and therefore public variables tied to the context (this)are always looked up in the prototype chain? - Private variables are always looked up in the scope chain

I've been reading this article about closures in which they say: "all the plumbing is automatic" the compiler "creates a wrapper class" and "extends the life of the variables" "you can use local variables without worry" the .NET compiler takes care of the plumbing for you, etc. So I made an example based on their code and to me, it seems as though closures just act similarly to regular named methods which also "take care of the local variables without worry" and in which "all the plumbing is automatic". Or what problem did this "wrapping of local variables" solve that makes closures so special

Personally I prefer callback over delegate in Swift for simple logical correlations, because it's pretty straight-forward and easy to understand. At the same time, some prefers delegate, since delegation is a popular pattern in other languages, such as C#. There are some discussions I found online: 1. "Why you shouldn't use delegates in Swift?" https://medium.cobeisfresh.com/why-you-shouldn-t-use-delegates-in-swift-7ef808a7f16b#.hqb7zrc1v 2. Apple is shifting its focus more on the callback pattern https://www.reddit.com/r/swift/comments/2ces1q/closures_vs_delegates/ 3. blocks or delegates?