closures

Possible Duplicate: What are ‘closures’ in .NET? I am currently looking at lambda expression and the word closure keeps coming. Can someone explain it to me in real simple language. Jorge Córdoba I'd say this is a duplicate of: What are ‘closures’ in .NET? "In essence, a closure is a block of code which can be executed at a later time, but which maintains the environment in which it was first created - i.e. it can still use the local variables etc of the method which created it, even after that method has finished executing." Your shoes are in the hall; your jacket is in the kitchen. Put them

Is it true that a closure is created in the following cases for foo , but not for bar ? Case 1: <script type="text/javascript"> function foo() { } </script> foo is a closure with a scope chain with only the global scope. Case 2: <script type="text/javascript"> var i = 1; function foo() { return i; } </script> same as Case 1. Case 3: <script type="text/javascript"> function Circle(r) { this.r = r; } Circle.prototype.foo = function() { return 3.1415 * this.r * this.r } </script> in this case, Circle.prototype.foo (which returns the circle's area) refers to a closure with only the global scope.

To me a Closure is a (nested?) function with co-located data. When you write software in Haskell and look it through afterwards, you frequently find closures that you have created unintentionally. I do not quite get this right for myself. In what situations would I intentionally want to code closures? After all, in all examples I find the amount of co-located data is trivial/small and thus it does not quite seem to me as if in practice that would ever justify their (intentional) creation. Is there any Haskell module that would support me in intentionally creating closures and e.g. storing them

Do I need to set MyAction to null so that garbage collection will be able to proceed with either of these classes? I am less concerned when both classes are to have almost the same lifespan. My question is more appropriate when Class1’s lifespan is much longer then Class2 or when Class2’s lifespan is much longer then Class1. The code here is stripped down. Assume that both Class1 and Class2 contain other members and methods that may affect their lifespan. public class Class1 : IDisposable { public Action<string> MyAction { get; set; } // Is this necessary? public void Dispose() { MyAction =

So I found this piece of code and it obviously works (as it has been in production for years): window[someMethod] = function (tmp) { callback({prop:"val"}, tmp); // Garbage collect window[someMethod] = undefined; try { delete window[someMethod]; } catch (e) { } if (head) { head.removeChild(script); } // head refers to DOM head elem and script refers to some script file elem }; Curious to know, how does it work? How can it set itself to undefined within its body and try to delete itself? Does the browser know to not execute the undefined and delete until the call is finished? And how? If the

I've been trying to work out how to implement Church-encoded data types in Scala. It seems that it requires rank-n types since you would need a first-class const function of type forAll a. a -> (forAll b. b -> b) . However, I was able to encode pairs thusly: import scalaz._ trait Compose[F[_],G[_]] { type Apply = F[G[A]] } trait Closure[F[_],G[_]] { def apply[B](f: F[B]): G[B] } def pair[A,B](a: A, b: B) = new Closure[Compose[({type f[x] = A => x})#f, ({type f[x] = B => x})#f]#Apply, Id] { def apply[C](f: A => B => C) = f(a)(b) } For lists, I was able to encode cons : def cons[A](x: A) = {

A couple of years ago I started writing an interpreter for a little Domain Specific Language which included programmer-defined functions. At first I implemented variable scope using a simple stack of symbol-tables. But now I want to move to proper lexical scoping (with the option of closures). Can anyone explain the data-structure and algorithm behind lexical scope? To get correct lexical scoping and closures in an interpreter, all you need to do is follow these rules: In your interpreter, variables are always looked up in an environment table passed in by the caller or kept as a variable ,

As far as I know, function foo() { aaa(); } is just var foo = function(){ aaa() } in JavaScript. So adding function foo() { bbb(); } should either overwrite the foo variable, or ignore the second definition - that's not the point. The point is that there should be one variable foo . So, in this example the me variable should not be correctly resolved from inside the methods and it is not in Explorer 8 :-) . I came to this example by trying to wrap them into another closure where ( var ) me would be, but I was surprised that it's not necessary: var foo = { bar1 : function me() { var index = 1;