Closures/Value capture

From Rosetta Code
Jump to: navigation, search
Task
Closures/Value capture
You are encouraged to solve this task according to the task description, using any language you may know.

Task: Create a list of 10 functions, in the simplest manner possible (anonymous functions are encouraged), such that the function at index i (you may choose to start i from either 0 or 1), when run, should return the square of the index, that is, i2. Display the result of running any but the last function, to demonstrate that the function indeed remembers its value.

Goal: To demonstrate how to create a series of independent closures based on the same template but maintain separate copies of the variable closed over. In imperative languages, one would generally use a loop with a mutable counter variable. For each function to maintain the correct number, it has to capture the value of the variable at the time it was created, rather than just a reference to the variable, which would have a different value by the time the function was run.

Contents

[edit] Ada

One way to realize closures in Ada is the usage of protected objects.

with Ada.Text_IO;
 
procedure Value_Capture is
 
protected type Fun is -- declaration of the type of a protected object
entry Init(Index: Natural);
function Result return Natural;
private
N: Natural := 0;
end Fun;
 
protected body Fun is -- the implementation of a protected object
entry Init(Index: Natural) when N=0 is
begin -- after N has been set to a nonzero value, it cannot be changed any more
N := Index;
end Init;
function Result return Natural is (N*N);
end Fun;
 
A: array (1 .. 10) of Fun; -- an array holding 10 protected objects
 
begin
for I in A'Range loop -- initialize the protected objects
A(I).Init(I);
end loop;
 
for I in A'First .. A'Last-1 loop -- evaluate the functions, except for the last
Ada.Text_IO.Put(Integer'Image(A(I).Result));
end loop;
end Value_Capture;
Output:
 1 4 9 16 25 36 49 64 81


[edit] ALGOL 68

Works with: ALGOL 68G version 2.8
 
[1:10]PROC(BOOL)INT squares;
 
FOR i FROM 1 TO 10 DO
HEAP INT captured i := i;
squares[i] := ((REF INT by ref i, INT by val i,BOOL b)INT:(INT i = by ref i; (b|by ref i := 0); by val i*i))
(captured i, captured i,)
OD;
 
FOR i FROM 1 TO 8 DO print(squares[i](i MOD 2 = 0)) OD;
print(new line);
FOR i FROM 1 TO 10 DO print(squares[i](FALSE)) OD
 
 
Output:
         +1         +4         +9        +16        +25        +36        +49        +64
         +1         +0         +9         +0        +25         +0        +49         +0        +81       +100

Using partial parametrization as proposed in Algol Bulletin by Charles Lindsey. Algol68G does not support binding all actual parameters "partially" without deproceduring, so a PROC(BOOL)INT mode is used instead of a PROC INT. The variable captured i is passed twice, once by reference and once by value, to demonstrate that it is possible to capture both ways, and a little extra code is added to show that the closure can modify the captured variable.

[edit] Axiom

Using the Spad compiler:

)abbrev package TESTP TestPackage
TestPackage() : with
test: () -> List((()->Integer))
== add
test() == [(() +-> i^2) for i in 1..10]

This can be called from the interpreter using:

[x() for x in test()]
Output:
[1,4,9,16,25,36,49,64,81,100]
Type: List(Integer)

[edit] Babel

((main { 
{ iter
1 take bons 1 take
dup cp
{*} cp
3 take
append }
10 times
collect !
{eval %d nl <<} each }))
Output:
100
81
64
49
36
25
16
9
4
1

Essentially, a function has been constructed for each value to be squared (10 down to 1). The cp operator ensures that we generate a fresh copy of the number to be squared, as well as the code for multiplying, {*}. In the final each loop, we eval each of the constructed functions and output the result.

[edit] Bracmat

( -1:?i
& :?funcs
& whl
' ( 1+!i:<10:?i
& !funcs ()'(.$i^2):?funcs
)
& whl'(!funcs:%?func %?funcs&out$(!func$))
);
 
Output:
0
1
4
9
16
25
36
49
64

[edit] C

[edit] Function image copying approach

Non-portable. Copying a function body depends on implementation-specific semantics of volatile, if the replacement target still exists after optimization, if the dest memory is suitably aligned, if the memory is executable, if it makes any function calls to a relative offset, if it refers to any memory location with an absolute address, etc. It only very occasionally works.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>
 
typedef int (*f_int)();
 
#define TAG 0xdeadbeef
int _tmpl() {
volatile int x = TAG;
return x * x;
}
 
#define PROT (PROT_EXEC | PROT_WRITE)
#define FLAGS (MAP_PRIVATE | MAP_ANONYMOUS)
f_int dupf(int v)
{
size_t len = (void*)dupf - (void*)_tmpl;
f_int ret = mmap(NULL, len, PROT, FLAGS, 0, 0);
char *p;
if(ret == MAP_FAILED) {
perror("mmap");
exit(-1);
}
memcpy(ret, _tmpl, len);
for (p = (char*)ret; p < (char*)ret + len - sizeof(int); p++)
if (*(int *)p == TAG) *(int *)p = v;
return ret;
}
 
int main()
{
f_int funcs[10];
int i;
for (i = 0; i < 10; i++) funcs[i] = dupf(i);
 
for (i = 0; i < 9; i++)
printf("func[%d]: %d\n", i, funcs[i]());
 
return 0;
}
Output:
func[0]: 0
func[1]: 1
func[2]: 4
func[3]: 9
func[4]: 16
func[5]: 25
func[6]: 36
func[7]: 49
func[8]: 64

[edit] Greenspunned mini Lisp dialect

See Closures/Variable_capture/C for complete code. The relevant excerpt is:

void init(void)
{
t = intern(lit("t"));
x = intern(lit("x"));
}
 
val square(val env)
{
val xbind = assoc(env, x); /* look up binding of variable x in env */
val xval = cdr(xbind); /* value is the cdr of the binding cell */
return num(cnum(xval) * cnum(xval));
}
 
int main(void)
{
int i;
val funlist = nil, iter;
 
init();
 
for (i = 0; i < 10; i++) {
val closure_env = cons(cons(x, num(i)), nil);
funlist = cons(func_f0(closure_env, square), funlist);
}
 
for (iter = funlist; iter != nil; iter = cdr(iter)) {
val fun = car(iter);
val square = funcall(fun, nao);
 
printf("%d\n", cnum(square));
}
return 0;
}

Here, we create an environment explicitly as an association list which we can search with the assoc function. The environment contains a binding for the symbol x. The square function retrieves the value and returns its square.

Output:
$ ./a.out
81
64
49
36
25
16
9
4
1
0

[edit] C++

Works with: C++11
#include <iostream>
#include <functional>
#include <vector>
 
int main() {
std::vector<std::function<int()> > funcs;
for (int i = 0; i < 10; i++)
funcs.push_back([=]() { return i * i; });
for ( std::function<int( )> f : funcs )
std::cout << f( ) << std::endl ;
return 0;
}
Output:
0
1
4
9
16
25
36
49
64
81

[edit] C#

[edit] Using Linq

using System;
using System.Linq;
 
class Program
{
static void Main()
{
var captor = (Func<int, Func<int>>)(number => () => number * number);
var functions = Enumerable.Range(0, 10).Select(captor);
foreach (var function in functions.Take(9))
{
Console.WriteLine(function());
}
}
}
Output:
0
1
4
9
16
25
36
49
64

[edit] Using delegates only

 
using System;
using System.Collections.Generic;
 
class Program
{
static void Main( string[] args )
{
List<Func<int>> l = new List<Func<int>>();
for ( int i = 0; i < 10; ++i )
{
// This is key to avoiding the closure trap, because
// the anonymous delegate captures a reference to
// outer variables, not their value. So we create 10
// variables, and each created anonymous delegate
// has references to that variable, not the loop variable
var captured_val = i;
l.Add( delegate() { return captured_val * captured_val; } );
}
 
l.ForEach( delegate( Func<int> f ) { Console.WriteLine( f() ); } );
}
}
 
Output:
0
1
4
9
16
25
36
49
64


[edit] CoffeeScript

 
# Generate an array of functions.
funcs = ( for i in [ 0...10 ] then do ( i ) -> -> i * i )
 
# Call each function to demonstrate value capture.
console.log func() for func in funcs
 

[edit] Common Lisp

CL-USER> (defparameter alist
(loop for i from 1 to 10
collect (cons i (let ((i i))
(lambda () (* i i))))))
ALIST
CL-USER> (funcall (cdr (assoc 2 alist)))
4
CL-USER> (funcall (cdr (assoc 8 alist)))
64

The loop mutates its binding i. The purpose of (let ((i i)) ...) is to create a different binding i for each lambda to capture. Otherwise, all 10 lambdas would capture the same binding and return 100.

[edit] D

[edit] Less Functional Version

import std.stdio;
 
void main() {
int delegate()[] funcs;
 
foreach (i; 0 .. 10)
funcs ~= (i => () => i ^^ 2)(i);
 
writeln(funcs[3]());
}
Output:
9

[edit] More Functional Version

void main() {
import std.stdio, std.range, std.algorithm;
 
10.iota.map!(i => () => i ^^ 2).map!q{ a() }.writeln;
}
Output:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[edit] Emacs Lisp

Emacs Lisp now has lexical-let, which allows for the capture of variables.

 
(require 'cl)
(mapcar 'funcall
(mapcar (lambda (x)
(lexical-let ((x x))
(lambda () (* x x)))) [1 2 3 4 5 6 7 8 9 10]))
;; => (1 4 9 16 25 36 49 64 81 100)
 

[edit] Erlang

Erlang uses lexical scoping and has anonymous functions.

 
-module(capture_demo).
-export([demo/0]).
 
demo() ->
Funs = lists:map(fun (X) ->
fun () ->
X * X
end
end,
lists:seq(1,10)),
lists:foreach(fun (F) ->
io:fwrite("~B~n",[F()])
end, Funs).
 
1> capture_demo:demo().
1
4
9
16
25
36
49
64
81
100
ok

[edit] Factor

[edit] Using lexical variables

USING: io kernel locals math prettyprint sequences ;
 
[let
 ! Create a sequence of 10 quotations
10 iota [
 :> i  ! Bind lexical variable i
[ i i * ]  ! Push a quotation to calculate i squared
] map :> seq
 
{ 3 8 } [
dup pprint " squared is " write
seq nth call .
] each
]
$ ./factor script.factor
3 squared is 9
8 squared is 64

The code :> i always binds a new variable. This happens inside a loop, so this program creates 10 different bindings. Each closure [ i i * ] captures a different binding, and remembers a different value.

The wrong way would use f :> i! 10 iota [ i! [ i i * ] ] map :> seq to mutate a single binding. Then the program would print, "3 squared is 81", "8 squared is 81".

[edit] Using fried quotations

Forget the variable! Each fried quotation captures some values by pulling them from the stack.

USING: fry io kernel math prettyprint sequences ;
 
! Push a sequence of 10 quotations
10 iota [
'[ _ dup * ]  ! Push a quotation ( i -- i*i )
] map
 
{ 3 8 } [
dup pprint " squared is " write
over nth call .
] each
drop

[edit] Fantom

 
class Closures
{
Void main ()
{
// define a list of functions, which take no arguments and return an Int
|->Int|[] functions := [,]
 
// create and store a function which returns i*i for i in 0 to 10
(0..10).each |Int i|
{
functions.add (|->Int| { i*i })
}
 
// show result of calling function at index position 7
echo ("Function at index: " + 7 + " outputs " + functions[7].call)
}
}
 
Output:
Function at index: 7 outputs 49

[edit] Go

package main
 
import "fmt"
 
func main() {
fs := make([]func() int, 10)
for i := range fs {
i := i
fs[i] = func() int {
return i * i
}
}
fmt.Println("func #0:", fs[0]())
fmt.Println("func #3:", fs[3]())
}
Output:
func #0: 0
func #3: 9

[edit] Groovy

Solution:

def closures = (0..9).collect{ i -> { -> i*i } }

Test:

assert closures instanceof List
assert closures.size() == 10
closures.each { assert it instanceof Closure }
println closures[7]()
Output:
49

[edit] Haskell

Using map:

fs = map (\i _ -> i * i) [1 .. 10]

Using list comprehensions:

fs = [const $ i * i | i <- [1 .. 10]]

Using infinite lists:

fs = take 10 coFs where coFs = [const $ i * i | i <- [1 ..]]

Testing:

> :t fs
fs :: [b -> Integer]
> map ($ ()) fs
[1,4,9,16,25,36,49,64,81,100]
> fs !! 9 $ ()
100
> fs !! 8 $ undefined
81

[edit] Icon and Unicon

This uses Unicon specific calling sequences for co-expressions. It can be made to run under Icon by modifying the calling syntax.

procedure main(args)                                      # Closure/Variable Capture
every put(L := [], vcapture(1 to 10)) # build list of index closures
write("Randomly selecting L[",i := ?*L,"] = ",L[i]()) # L[i]() calls the closure
end
 
# The anonymous 'function', as a co-expression. Most of the code is standard
# boilerplate needed to use a co-expression as an anonymous function.
 
procedure vcapture(x) # vcapture closes over its argument
return makeProc { repeat { (x[1]^2) @ &source } }
end
 
procedure makeProc(A) # the makeProc PDCO from the UniLib Utils package
return (@A[1], A[1])
end

package Utils provides makeProc Summary of Anonymous Functions in Unicon

Output:
Randomly selecting L[8] = 64

[edit] J

[edit] Explicit version

The natural way of implementing this in J is to define a function which produces a gerund of a constant function.

constF=:3 :0
{.''`(y "_)
)

Thus, a list of 10 functions each producing a value in 0..9, and another with their squares:

flist=: constF"0 i.10
slist=: constF"0 *:i.10

Referencing a function:

   flist @.3
3"_
slist @.3
9"_

Using a function:

   flist @.4''
4
slist @.4''
16

Running a randomly picked function which is not the last one:

   flist@.(?9) ''
7
slist@.(?9) ''
25

[edit] Tacit (unorthodox) version

In J only adverbs and conjunctions (functionals) can produce verbs (functions)... Unless they are forced to cloak as verbs; in this instance, the rank conjunction (“) cloaks as a dyadic verb.

   ( VL=. (<@:((<'"')(0:`)(,^:)&_))"0@:(^&2)@:i. 10 ) NB. Producing a list of boxed anonymous verbs (functions)
┌───┬───┬───┬───┬────┬────┬────┬────┬────┬────┐
0"_1"_4"_9"_16"_25"_36"_49"_64"_81"_
└───┴───┴───┴───┴────┴────┴────┴────┴────┴────┘
 
{::&VL 5 NB. Evoking the 6th verb (function)
25"_
{::&VL 5 '' NB. Invoking the 6th verb with a dummy argument ('')
25

[edit] Java

Works with: Java version 8+
import java.util.function.Supplier;
import java.util.ArrayList;
 
public class ValueCapture {
public static void main(String[] args) {
ArrayList<Supplier<Integer>> funcs = new ArrayList<>();
for (int i = 0; i < 10; i++) {
int j = i;
funcs.add(() -> j * j);
}
 
Supplier<Integer> foo = funcs.get(3);
System.out.println(foo.get()); // prints "9"
}
}
Alternative implementation that also
Works with: Java version 8+
import java.util.List;
import java.util.function.IntSupplier;
import java.util.stream.IntStream;
 
import static java.util.stream.Collectors.toList;
 
public interface ValueCapture {
public static void main(String... arguments) {
List<IntSupplier> closures = IntStream.rangeClosed(0, 10)
.<IntSupplier>mapToObj(i -> () -> i * i)
.collect(toList())
;
 
IntSupplier closure = closures.get(3);
System.out.println(closure.getAsInt()); // prints "9"
}
}

[edit] JavaScript

var funcs = [];
for (var i = 0; i < 10; i++) {
funcs.push( (function(i) {
return function() { return i * i; }
})(i) );
}
window.alert(funcs[3]()); // alerts "9"
Works with: JavaScript version 1.7+
(Firefox 2+)
<script type="application/javascript;version=1.7">
var funcs = [];
for (var i = 0; i < 10; i++) {
let (i = i) {
funcs.push( function() { return i * i; } );
}
}
window.alert(funcs[3]()); // alerts "9"
</script>

[edit] Julia

funcs = [ () -> i^2 for i = 1:10 ]
Output:
julia> funcs[7]()
49

[edit] Logtalk

The example that follow uses Logtalk's native support for lambda expressions.

 
:- object(value_capture).
 
:- public(show/0).
show :-
integer::sequence(1, 10, List),
meta::map(create_closure, List, Closures),
meta::map(call_closure, List, Closures).
 
create_closure(Index, [Double]>>(Double is Index*Index)).
 
call_closure(Index, Closure) :-
call(Closure, Result),
write('Closure '), write(Index), write(' : '), write(Result), nl.
 
:- end_object.
 
Output:
 
| ?- value_capture::show.
Closure 1 : 1
Closure 2 : 4
Closure 3 : 9
Closure 4 : 16
Closure 5 : 25
Closure 6 : 36
Closure 7 : 49
Closure 8 : 64
Closure 9 : 81
Closure 10 : 100
yes
 

[edit] Lua

 
funcs={}
for i=1,10 do
table.insert(funcs, function() return i*i end)
end
funcs[2]()
funcs[3]()
 
Output:
4
9

[edit] Maple

> L := map( i -> (() -> i^2), [seq](1..10) ):
> seq( L[i](),i=1..10);
1, 4, 9, 16, 25, 36, 49, 64, 81, 100
> L[4]();
16
 

[edit] Mathematica

Function[i, i^2 &] /@ Range@10
->{1^2 &, 2^2 &, 3^2 &, 4^2 &, 5^2 &, 6^2 &, 7^2 &, 8^2 &, 9^2 &, 10^2 &}
 
%[[2]][]
->4

[edit] Nemerle

using System.Console;
 
module Closures
{
Main() : void
{
def f(x) { fun() { x ** 2 } }
def funcs = $[f(x) | x in $[0 .. 10]].ToArray(); // using array for easy indexing
 
WriteLine($"$(funcs[4]())");
WriteLine($"$(funcs[2]())");
}
}
Output:
16
4

[edit] Nimrod

var funcs: seq[proc(): int] = @[]
 
for i in 0..9:
let x = i
funcs.add(proc (): int = x * x)
 
for i in 0..8:
echo "func[", i, "]: ", funcs[i]()

[edit] Objective-C

Works with: Cocoa version Mac OS X 10.6+
with ARC
NSMutableArray *funcs = [[NSMutableArray alloc] init];
for (int i = 0; i < 10; i++) {
[funcs addObject:[^ { return i * i; } copy]];
}
 
int (^foo)(void) = funcs[3];
NSLog(@"%d", foo()); // logs "9"
 

[edit] OCaml

All functions in OCaml are closures.

let () =
let cls = Array.init 10 (fun i -> (function () -> i * i)) in
Random.self_init ();
for i = 1 to 6 do
let x = Random.int 9 in
Printf.printf " fun.(%d) = %d\n" x (cls.(x) ());
done
Output:
 fun.(4) = 16
 fun.(1) = 1
 fun.(4) = 16
 fun.(7) = 49
 fun.(3) = 9
 fun.(6) = 36

[edit] PARI/GP

Works with: PARI/GP version 2.4.2 and above
vector(10,i,()->i^2)[5]()
Output:
%1 = 25

[edit] Perl

my @f = map(sub { $_ * $_ }, 0 .. 9);   # @f is an array of subs
print $f[$_](), "\n" for (0 .. 8); # call and print all but last
Output:
0
1
4
9
16
25
36
49
64

[edit] Perl 6

All blocks are anonymous closures in Perl 6, and parameters are lexicals, so it's easy to generate a list of them. We'll use a gather/take generator loop, and call the closures in random order, just to keep things interesting.

my @c = gather for ^10 -> $i {
take { $i * $i }
}
 
.().say for @c.pick(*); # call them in random order
Output:
36
64
25
1
16
0
4
9
81
49

Or equivalently, using a more functional notation:

say .() for pick *, map -> $i { -> {$i * $i} }, ^10

[edit] PHP

Works with: PHP version 5.3+
<?php
$funcs = array();
for ($i = 0; $i < 10; $i++) {
$funcs[] = function () use ($i) { return $i * $i; };
}
echo $funcs[3](), "\n"; // prints 9
?>
Works with: PHP version pre-5.3

This method can capture value types like numbers, strings, arrays, etc., but not objects.

<?php
$funcs = array();
for ($i = 0; $i < 10; $i++) {
$funcs[] = create_function('', '$i = ' . var_export($i, true) . '; return $i * $i;');
}
echo $funcs[3](), "\n"; // prints 9
?>

[edit] PicoLisp

(setq FunList
(make
(for @N 10
(link (curry (@N) () (* @N @N))) ) ) )

Test:

: ((get FunList 2))
-> 4

: ((get FunList 8))
-> 64

[edit] Pike

array funcs = ({});
foreach(enumerate(10);; int i)
{
funcs+= ({
lambda(int j)
{
return lambda()
{
return j*j;
};
}(i)
});
}

[edit] Prolog

Works with SWI-Prolog and module lambda.pl from Ulrich Neumerkel.
lambda.pl can be found there : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

:-use_module(library(lambda)).
 
 
closure :-
numlist(1,10, Lnum),
maplist(make_func, Lnum, Lfunc),
maplist(call_func, Lnum, Lfunc).
 
 
make_func(I, \X^(X is I*I)).
 
call_func(N, F) :-
call(F, R),
format('Func ~w : ~w~n', [N, R]).
 
Output:
 ?- closure.
Func 1 : 1
Func 2 : 4
Func 3 : 9
Func 4 : 16
Func 5 : 25
Func 6 : 36
Func 7 : 49
Func 8 : 64
Func 9 : 81
Func 10 : 100
true.

[edit] Python

The naive way does not work:

funcs = []
for i in range(10):
funcs.append(lambda: i * i)
print funcs[3]() # prints 81

The simplest solution is to add optional parameters with default arguments at the end of the parameter list, to create a local copy of the variable, and evaluate the variable at the time the function is created. (The optional parameter is not expected to ever be passed.) Often, the optional parameter will be named the same as the variable to be closed over (leading to odd-looking code of the form foo=foo in the arguments), so that the code inside the function need not be changed, but this might lead to confusion. This technique does not work for functions with a variable number of arguments.

funcs = []
for i in range(10):
funcs.append(lambda i=i: i * i)
print funcs[3]() # prints 9

or equivalently the list comprehension:

funcs = [lambda i=i: i * i for i in range(10)]
print funcs[3]() # prints 9

Another solution is to wrap an immediately-executed function around our function. The wrapping function creates a new scope, and its execution forces the evaluation of the variable to be closed over.

funcs = []
for i in range(10):
funcs.append((lambda i: lambda: i * i)(i))
print funcs[3]() # prints 9

or equivalently the list comprehension:

funcs = [(lambda i: lambda: i)(i * i) for i in range(10)]
print funcs[3]() # prints 9

In this case it is also possible to use map() since the function passed to it creates a new scope

funcs = map(lambda i: lambda: i * i, range(10))
print funcs[3]() # prints 9

It is also possible to use eval.

funcs=[eval("lambda:%s"%i**2)for i in range(10)]
print funcs[3]() # prints 9

[edit] R

R is a natural language for this task, but you need to understand the nuances of delayed evaluation. Arguments in R are referred to as promises because they aren't evaluated until first use. If you're not careful, you can bind to a promise that hasn't yet been evaluated, and you won't get what you expect.

 
# assign 's' a list of ten functions
s <- sapply (1:10, # integers 1..10 become argument 'x' below
function (x) {
x # force evaluation of promise x
function (i=x) i*i # this *function* is the return value
})
 
s[[5]]() # call the fifth function in the list of returned functions
[1] 25 # returns vector of length 1 with the value 25
 

Note that I bound the captured variable as the default argument on a unary function. If you supply your own argument, as below, it squares the supplied argument and ignores the default argument.

 
s[[5]](10)
[1] 100
 

As a further technicality, note that you need some extra voodoo to modify the bound argument with persistence across calls. This example increments the bound variable after each call.

 
s <- sapply (1:10,
function (x) {
x # force evaluation of promise x
function () {
R <- x*x
# evaluate the language expression "x <- x + 1" in the persistent parent environment
evalq (x <- x + 1, parent.env(environment()))
R # return squared value
}})
 
s[[5]]()
[1] 25 # 5^2
s[[5]]()
[1] 36 # now 6^2
s[[1]]()
[1] 1 # 1^2
s[[1]]()
[1] 4 # now 2^2
 

As shown, each instance increments separately.

[edit] Racket

 
#lang racket
(map (λ(f) (f))
(for/list ([i 10]) (λ () (* i i))))
 
Output:
 
'(0 1 4 9 16 25 36 49 64 81)
 

[edit] REXX

/*REXX pgm has a list of 10 functions, each returns its invocation(idx)²*/
 
do j=1 for 9 /*invoke random functions 9 times.*/
interpret 'CALL .'random(0,9) /*invoke a randomly selected func.*/
end /*j*/ /* [↑] the random func has no args*/
 
say 'The tenth invocation of .0 ───► ' .0()
exit /*stick a fork in it, we're done.*/
/*─────────────────────────────────list of 10 functions─────────────────*/
/*[Below is the closest thing to anonymous functions in the REXX lang.] */
.0:return .(); .1:return .(); .2:return .(); .3:return .(); .4:return .()
.5:return .(); .6:return .(); .7:return .(); .8:return .(); .9:return .()
/*─────────────────────────────────. function───────────────────────────*/
.: if symbol('@')=='LIT' then @=0 /*handle 1st invoke*/; @=@+1; return @*@
Output:
The tenth invocation of  .0  ───►  100

[edit] Ruby

list = {}
(1..10).each {|i| list[i] = proc {i * i}}
p list[3].call #=> 9
p list[7][] #=> 49
i = 5
p list[3].call #=> 9

This works because i in (1..10).each {|i| ...} is local to its block. The loop calls the block 10 times, so there are 10 different variables to capture.

With Ruby 1.9, i is always local to its block. With Ruby 1.8, i is local unless there is another i in the outer scope. If i is not local, all 10 procs will return 100.

However, (on both Ruby 1.8 and 1.9) when using a for loop, the loop variable is shared and not local to each iteration:

list = {}
for i in 1..10 do list[i] = proc {i * i} end
p list[3][] #=> 100
i = 5
p list[3][] #=> 25

[edit] Rust

fn main() { 
let fs: ~[proc() -> uint] = range(0u,10).map(|i| {proc() i*i}).collect();
println!("7th val: {}", fs[7]());
}
 

$ rustc rosetta.rs

$ ./rosetta

7th val: 49

[edit] Scheme

;;; Collecting lambdas in a tail-recursive function.
(define (build-list-of-functions n i list)
(if (< i n)
(build-list-of-functions n (+ i 1) (cons (lambda () (* (- n i) (- n i))) list))
list))
 
(define list-of-functions (build-list-of-functions 11 1 '()))
 
(map (lambda (f) (f)) list-of-functions)
 
((list-ref list-of-functions 8))
Output:
(1 4 9 16 25 36 49 64 81 100)
81

[edit] Scala

val closures=for(i <- 0 to 9) yield (()=>i*i)
0 to 8 foreach (i=> println(closures(i)()))
println("---\n"+closures(7)())
Output:
0
1
4
9
16
25
36
49
64
---
49

[edit] Sidef

var f = (
0..9 -> map {|i| func(j){i * j}.copy }
);
 
0 ..^ 8 -> each { |j|
say f[j].call(j);
};
Output:
0
1
4
9
16
25
36
49
64

[edit] Smalltalk

funcs := (1 to: 10) collect: [ :i | [ i * i ] ] .
(funcs at: 3) value displayNl .
Output:
9

[edit] Sparkling

In Sparkling, upvalues (variables in the closure) are captured by value.

var fnlist = {};
for var i = 0; i < 10; i++ {
fnlist[i] = function() {
return i * i;
};
}
 
print(fnlist[3]()); // prints 9
print(fnlist[5]()); // prints 25

Alternately:

var fnlist = map(range(10), function(k, v) {
return function() {
return v * v;
};
});
 
print(fnlist[3]()); // prints 9
print(fnlist[5]()); // prints 25

[edit] Swift

By default, Swift captures variables by reference. A naive implementation like the following C-style for loop does not work:

var funcs: [() -> Int] = []
for var i = 0; i < 10; i++ {
funcs.append({ i * i })
}
println(funcs[3]()) // prints 100

However, using a for-in loop over a range does work, since you get a new constant at every iteration:

var funcs: [() -> Int] = []
for i in 0..<10 {
funcs.append({ i * i })
}
println(funcs[3]()) // prints 9

The C-style for loop can also work if we explicitly capture the loop counter:

var funcs: [() -> Int] = []
for var i = 0; i < 10; i++ {
funcs.append({ [i] in i * i })
}
println(funcs[3]()) // prints 9

Alternately, we can also use map() to map over a range, and create the squaring closure inside the mapping closure which has the integer as a parameter:

let funcs = [] + map(0..<10) {i in { i * i }}
println(funcs[3]()) // prints 9

[edit] Tcl

Tcl does not support closures (either value-capturing or variable-capturing) by default, but value-capturing closures are easy to emulate.

package require Tcl 8.6; # Just for tailcall command
# Builds a value-capturing closure; does NOT couple variables
proc closure {script} {
set valuemap {}
foreach v [uplevel 1 {info vars}] {
lappend valuemap [list $v [uplevel 1 [list set $v]]]
}
set body [list $valuemap $script [uplevel 1 {namespace current}]]
# Wrap, to stop untoward argument passing
return [list apply [list {} [list tailcall apply $body]]]
# A version of the previous line compatible with Tcl 8.5 would be this
# code, but the closure generated is more fragile:
### return [list apply $body]
}
 
# Simple helper, to avoid capturing unwanted variable
proc collectFor {var from to body} {
upvar 1 $var v
set result {}
for {set v $from} {$v < $to} {incr v} {lappend result [uplevel 1 $body]}
return $result
}
# Build a list of closures
proc buildList {} {
collectFor i 0 10 {
closure {
# This is the body of the closure
return [expr $i*$i]
}
}
}
set theClosures [buildList]
foreach i {a b c d e} {# Do 5 times; demonstrates no variable leakage
set idx [expr {int(rand()*9)}]; # pick random int from [0..9)
puts $idx=>[{*}[lindex $theClosures $idx]]
}
Output:
5=>25
0=>0
8=>64
1=>1
8=>64

[edit] zkl

Create a closure of the index over a square function

(0).pump(10,List,fcn(i){i*i}.fp)[8]() //-->64
list:=(0).pump(10,List,fcn(i){i*i}.fp);
foreach n in (list.len()-1) { list[n]().println() }
list.run(True).println()
Output:
0
1
4
9
16
25
36
49
64
L(0,1,4,9,16,25,36,49,64,81)
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox