Closure Because of What it Can Do or Because it Does

Question

Ok, this is a bit of a pedantic question but I'd like to make sure I'm understanding the definition correctly. Is the closure moniker used to describe anonymous functions that can lift variables in the local scope (Whether they actually do or not) or only when they do lift variables in local scope?

In other words if an anonymous function has the ability to lift variables in its local scope (Because the language offers that capability) but doesn't, is it still considered a closure?

My understanding is that it is a closure only when local variables are lifted. But an anonymous function that doesn't (Even though it can) is not a closure. So not all anonymous functions are closures but all closures are anonymous functions.

Again, sorry for the pedantry, but these things gnaw at me. :)

Answer 1

Assuming you mean within the context of computer science...

A closure is a first class function which captures the lexical bindings of free variables in its defining environment. Once it has captured the lexical bindings the function becomes a closure because it "closes over" those variables.

Note this means closures only exist at run time.

For a function to be a closure is orthogonal to the function being anonymous or named. You can create a language that allows you to define named functions to be closures.

Here is a "named" closure in Python:

def maker():
  count=[0]
  def counter():
    count[0]=count[0]+1
    return count[0]
  return counter

Answer 2

One great definition of a closure is defined here: lua.org

When a function is written enclosed in another function, it has full access to local variables from the enclosing function; this feature is called lexical scoping. Although that may sound obvious, it is not. Lexical scoping, plus first-class functions, is a powerful concept in a programming language, but few languages support that concept.