- Concepts of Programming Languages

Closures

Instructor:

Learning Objectives

What if functions have free variables?

• Identify when a function has free variables
• Identify nested methods and functions
• Describe the effect of closures: how free variables are bound to variables of the environment

Nested Functions

• Useful to limit the scope of functions and to hide arguments

int fact (int n) {
  int loop(int n, int result) {
    if (n <= 1) {
      return result;
    } else {
      return loop(n - 1, n * result);
    }
  }
  return loop(n, 1);
}

$ gcc -c nested-fact.c 
$ gcc -pedantic -c nested-fact.c 
function.c: In function ‘fact’:
function.c:2:3: warning: ISO C forbids nested functions [-pedantic]

Nested Functions: Java and Scala

• Closures: nested functions in Scala and Java store environment on function definition

Closures: Problem Summary

def outer(x:A) : B=>C = 
  def inner(y:B) : C = 
    //...use x and y...
  end inner
  inner // return inner
end outer
val f = outer(...)
f(...)

• Mutable vs. immutable state?

Closures: Copy or Share

def outer(x:A) : B=>C = 
  def inner(y:B) : C = 
    // use x and y
    // free: x
    // bound: y
  end inner
  inner // return inner
end outer

Closures: Copy or Share

def outer(x:A) : B=>C = 
  var u:A = x
  def inner(y:B) : C = 
    // use x, u, and y: 
    // free: x, u
    // bound: y
  end inner
  u = u + 1
  inner // return inner
end outer

Closures: Scala

def outer(x:Int) : Boolean=>Int = 
  def inner(y:Boolean) : Int = 
    x + (if y then 0 else 1)
  end inner
  inner // return inner
end outer

public static Function1<Boolean, Integer> outer(int x) {
  return new Closure(x);
}
public final class Closure 
    extends AbstractFunction1<Boolean, Integer> {
  
  private final int x;
  
  public final Integer apply(Boolean y) {
    return x + (y ? 0 : 1);
  }
  
  public Closure(int x) { this.x = x; }
}

Closures: Scala

def outer (x:Int) : Boolean=>Int =
  var u:Int = x
  def inner (y:Boolean) : Int =
    x + u + (if y then 0 else 1)
  end inner
  u = u+1
  inner // return inner
end outer

public static Function1<Boolean, Integer> outer(int x) {
  IntRef u = new IntRef(x);
  var c = new Closure(x, u);
  u.elem = u.elem+1;
  return c;
}
public final class Closure 
    extends AbstractFunction1<Boolean, Integer> {
  private final int x;
  private final IntRef u;
  public final Integer apply(Boolean y) {
    return x + u.elem + (y ? 0 : 1);
  }
  public Closure(int x, IntRef u) {
    this.x = x;
    this.u = u;
  }
}

Example: Use Closures

How to create a "container" for data and functions?

public class Incrementor {
  private int i;
  public Incrementor(int i) { 
    this.i = i; 
  }
  public int increment(int x) {
    return x+i;
  }
}
// use object
Incrementor inc = new Incrementor(2);
inc.increment(4); // returns 6
inc.increment(5); // returns 7

def incrementor(i:Int) : Int=>Int = 
  (x:Int) => x+i
end incrementor
// use closure
val inc = incrementor(2)
inc(4) // returns 6
inc(5) // returns 7

Example: Interpret Closures

Example: Interpret Closures

Example: Use Closures

Implement a function that prints with an initializable string prefix:

val p = printer("> ")
println(p("hello"))
println(p("world!"))

• Return a function for printing that accesses the prefix argument

  def printer(prefix: String) : String=>String =
    (s: String) => prefix + s
  

Example: Use Closures

Implement a function that collects numbers and computes their average:

val cavg = cumulativeAvg()
cavg(2) // returns 2
cavg(4) // returns 3
cavg(6) // returns 4

• Initialize a list buffer, return a function that appends and then computes the average

  def cumulativeAvg(): Int=>Int =
    val data = scala.collection.mutable.ListBuffer.empty[Int]
    x => 
      data.append(x)
      data.sum / data.length
  end cumulativeAvg
  

Example: Use Closures

Implement a function to cache the results of another function:

def square(x: Int) = { println(s"$x^2"); x*x }
val cachedSquare = memoize(square)
cachedSquare(5) // prints 5^2 and returns 25
cachedSquare(5) // returns 25 without printing

• Initialize a cache, return function that consults the cache and updates it on demand

  def memoize[X,Y](fn: X=>Y) : X=>Y =
    val cache = scala.collection.mutable.Map.empty[X,Y]
    x => cache.getOrElseUpdate(x, fn(x))      
  

Example: Use Closures

Implement a map data structure from arrays and index access; wanted use:

val (get, put) = map(10)
put(3, "Hello")
put(6, "world!")
println(get(3))

• Return a tuple of functions that access a shared array

  def map(size: Int) : (Int=>String, (Int, String)=>Unit) = 
    val elems: Array[String] = Array.ofDim(size)
    
    def get(k: Int)            = elems(k)
    def put(k: Int, v: String) = elems(k) = v
    (get, put)  
  end map
  

Summary

• Closures are necessary when functions have free variables
• Closures bind free variables of a function to variables from the environment
• Closures align the lifetime of functions and their accessed environment
• Closures in Javascript