Closures/Value capture: Difference between revisions

{{task}}

 

 

See also: [[Multiple distinct objects]]

 

=={{header|Ada}}==

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

 

 

procedure Value_Capture is

Ada.Text_IO.Put(Integer'Image(A(I).Result));

end loop;

 

{{out}}

<pre> 1 4 9 16 25 36 49 64 81</pre>

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|2.8}}

 

[1:10]PROC(BOOL)INT squares;

 

FOR i FROM 1 TO 10 DO print(squares[i](FALSE)) OD

 

{{out}}

<pre>

 

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.

=={{header|AntLang}}==

=={{header|AppleScript}}==

{{trans|JavaScript}}

set fns to {}

end repeat

end run

 

on closure(x)

script

end script

{{Out}}

<pre>9</pre>

 

Or, in a more functional pattern of composition:

 

 

 

 

 

 

set lst to {}

end repeat

return lst

end map

 

 

 

 

 

<pre>9</pre>

=={{header|Axiom}}==

Using the Spad compiler:

TestPackage() : with

test: () -> List((()->Integer))

== add

 

This can be called from the interpreter using:

 

{{out}}

 

=={{header|Babel}}==

 

{ iter

1 take bons 1 take

10 times

collect !

 

{{out}}

81

64

9

4

 

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.

=={{header|Bracmat}}==

& :?funcs

& whl

& whl'(!funcs:%?func %?funcs&out$(!func$))

);

{{out}}

<pre>0

49

64</pre>

=={{header|C}}==

 

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 <string.h>

#include <stdlib.h>

return 0;

{{out}}

func[1]: 1

func[2]: 4

func[6]: 36

func[7]: 49

 

===Greenspunned mini Lisp dialect===

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

 

{

t = intern(lit("t"));

}

return 0;

 

Here, we create an environment explicitly as an association list

0

</pre>

=={{header|C sharp|C#}}==

===Using Linq===

using System.Linq;

 

}

}

{{out}}

1

4

36

49

 

===Using delegates only===

 

using System;

using System.Collections.Generic;

}

}

{{out}}

1

4

36

49

 

=={{header|Ceylon}}==

//create a list of closures with a list comprehension

print("closure number ``i`` returns: ``closure()``");

}

=={{header|Clojure}}==

{{Out}}

<pre>9

16</pre>

=={{header|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

=={{header|Common Lisp}}==

(loop for i from 1 to 10

collect (cons i (let ((i i))

4

CL-USER> (funcall (cdr (assoc 8 alist)))

 

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

=={{header|D}}==

===Less Functional Version===

 

void main() {

 

writeln(funcs[3]());

{{out}}

<pre>9</pre>

===More Functional Version===

import std.stdio, std.range, std.algorithm;

 

10.iota.map!(i => () => i ^^ 2).map!q{ a() }.writeln;

{{out}}

<pre>[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]</pre>

=={{header|Delphi}}==

{{works with|Delphi 2009}}

 

type

for i := Low(Funcs) to High(Funcs) do

Writeln(Funcs[i]());

{{out}}

<pre>0

81

</pre>

 

=={{header|EchoLisp}}==

(define (fgen i) (lambda () (* i i)))

(define fs (for/vector ((i 10)) (fgen i))) ;; vector of 10 anonymous functions

((vector-ref fs 5)) ;; calls fs[5]

→ 25

=={{header|Elena}}==

{{out}}

 

=={{header|Elixir}}==

 

{{out}}

81

</pre>

=={{header|Emacs Lisp}}==

 

=={{header|Erlang}}==

Erlang uses lexical scoping and has anonymous functions.

-module(capture_demo).

-export([demo/0]).

io:fwrite("~B~n",[F()])

end, Funs).

<pre>

1> capture_demo:demo().

ok

</pre>

Nearly identical to OCaml

let main argv =

let fs = List.init 10 (fun i -> fun () -> i*i)

do List.iter (fun f -> printfn "%d" <| f()) fs

 

With List.map

let main argv =

let fs = List.map (fun i -> fun () -> i*i) [0..9]

do List.iter (fun f -> printfn "%d" <| f()) fs

 

With List.mapi

let main argv =

let fs = List.mapi (fun i x -> fun () -> i*i) (List.replicate 10 None)

do List.iter (fun f -> printfn "%d" <| f()) fs

 

With an infinite sequence

let main argv =

let fs = Seq.initInfinite (fun i -> fun () -> i*i)

do Seq.iter (fun f -> printfn "%d" <| f()) (Seq.take 10 fs)

 

{{out}}

81

</pre>

=={{header|Factor}}==

===Using lexical variables===

 

[let

seq nth call .

] each

 

<pre>$ ./factor script.factor

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

 

 

! Push a sequence of 10 quotations

over nth call .

] each

=={{header|Fantom}}==

 

class Closures

{

}

}

 

{{out}}

Function at index: 7 outputs 49

</pre>

=={{header|Forth}}==

10 cells allot 10 0 do

:noname i ]] literal dup * ; [[ a i cells + !

loop a ;

 

 

{{out}}

 

 

=={{header|Go}}==

 

import "fmt"

fmt.Println("func #0:", fs[0]())

fmt.Println("func #3:", fs[3]())

{{out}}

<pre>

func #3: 9

</pre>

=={{header|Groovy}}==

Solution:

 

Test:

assert closures.size() == 10

closures.each { assert it instanceof Closure }

 

{{out}}

<pre>49</pre>

=={{header|Haskell}}==

 

Using <code>map</code>:

 

 

Using list comprehensions:

 

 

Using infinite lists:

 

 

Testing:

 

fs :: [b -> Integer]

> map ($ ()) fs

100

> fs !! 8 $ undefined

=={{header|Icon}} and {{header|Unicon}}==

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

 

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

procedure makeProc(A) # the makeProc PDCO from the UniLib Utils package

return (@A[1], A[1])

 

{{libheader|Unicon Code Library}}

<pre>Randomly selecting L[8] = 64</pre>

 

 

=={{header|J}}==

 

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

 

{.''`(y "_)

 

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

 

 

Referencing a function by its index (its position in that list):

 

3"_

slist @.3

 

Using a function, given its index:

 

4

slist @.4''

 

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

 

7

slist@.(?9) ''

 

===Tacit (unorthodox) version===

 

┌───┬───┬───┬───┬────┬────┬────┬────┬────┬────┐

│0"_│1"_│4"_│9"_│16"_│25"_│36"_│49"_│64"_│81"_│

25"_

{::&VL 5 '' NB. Invoking the 6th verb with a dummy argument ('')

 

=={{header|Java}}==

{{works with|Java|8+}}

import java.util.ArrayList;

 

System.out.println(foo.get()); // prints "9"

}

 

Alternative implementation that also {{works with|Java|8+}}

import java.util.function.IntSupplier;

import java.util.stream.IntStream;

System.out.println(closure.getAsInt()); // prints "9"

}

=={{header|JavaScript}}==

 

===Imperative===

 

for (var i = 0; i < 10; i++) {

funcs.push( (function(i) {

})(i) );

}

 

{{works with|JavaScript|1.7+}} (Firefox 2+)

var funcs = [];

for (var i = 0; i < 10; i++) {

}

window.alert(funcs[3]()); // alerts "9"

 

{{works with|JavaScript|ES6}}

let funcs = [];

for (let i = 0; i < 10; ++i) {

funcs.push((i => () => i*i)(i));

}

 

===Functional ===

{{works with|JavaScript|ES5}}

 

'use strict';

 

return lstFns[3]();

 

 

{{out}}

 

{{works with|JavaScript|ES6}}

{{out}}

<pre>

9

</pre>

=={{header|Julia}}==

{{out}}

<pre>

49

</pre>

 

=={{header|LFE}}==

 

Input at the REPL:

> (set funcs (list-comp ((<- m (lists:seq 1 10)))

(lambda () (math:pow m 2))))

 

Output:

(#Fun<lfe_eval.23.101079464> #Fun<lfe_eval.23.101079464>

#Fun<lfe_eval.23.101079464> #Fun<lfe_eval.23.101079464>

#Fun<lfe_eval.23.101079464> #Fun<lfe_eval.23.101079464>

#Fun<lfe_eval.23.101079464> #Fun<lfe_eval.23.101079464>)

 

Calling the functions:

> (funcall (car funcs))

1.0

64.0

 

 

=={{header|Logtalk}}==

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

:- object(value_capture).

 

 

:- end_object.

{{out}}

| ?- value_capture::show.

Closure 1 : 1

Closure 10 : 100

yes

=={{header|Lua}}==

funcs={}

for i=1,10 do

funcs[2]()

funcs[3]()

{{out}}

<pre>4

9

</pre>

 

=={{header|Maple}}==

> seq( L[i](),i=1..10);

1, 4, 9, 16, 25, 36, 49, 64, 81, 100

> L[4]();

16

=={{header|Mathematica}} / {{header|Wolfram Language}}==

->{1^2 &, 2^2 &, 3^2 &, 4^2 &, 5^2 &, 6^2 &, 7^2 &, 8^2 &, 9^2 &, 10^2 &}

 

%[[2]][]

=={{header|Nemerle}}==

 

module Closures

WriteLine($"$(funcs[2]())");

}

{{out}}

<pre>16

4</pre>

=={{header|Nim}}==

 

for i in 0..9:

 

for i in 0..8:

 

=={{header|Objective-C}}==

{{works with|Cocoa|Mac OS X 10.6+}} with ARC

for (int i = 0; i < 10; i++) {

[funcs addObject:[^ { return i * i; } copy]];

int (^foo)(void) = funcs[3];

NSLog(@"%d", foo()); // logs "9"

=={{header|OCaml}}==

 

All functions in OCaml are closures.

 

let cls = Array.init 10 (fun i -> (function () -> i * i)) in

Random.self_init ();

let x = Random.int 9 in

Printf.printf " fun.(%d) = %d\n" x (cls.(x) ());

 

{{out}}

fun.(6) = 36

</pre>

=={{header|Oforth}}==

 

{{out}}

49

</pre>

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.4.2 and above}}

 

{{out}}

<pre>%1 = 25</pre>

=={{header|Perl}}==

{{out}}

<pre>

64

</pre>

 

 

 

=={{header|PHP}}==

{{works with|PHP|5.3+}}

$funcs = array();

for ($i = 0; $i < 10; $i++) {

}

echo $funcs[3](), "\n"; // prints 9

 

{{works with|PHP|pre-5.3}}

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

$funcs = array();

for ($i = 0; $i < 10; $i++) {

}

echo $funcs[3](), "\n"; // prints 9

=={{header|PicoLisp}}==

(make

(for @N 10

Test:

<pre>: ((get FunList 2))

: ((get FunList 8))

-> 64</pre>

=={{header|Pike}}==

foreach(enumerate(10);; int i)

{

}(i)

});

=={{header|PowerShell}}==

I'm not sure that I understood the question/task. This task seems to be the same as the 'Accumulator Factory' task.

function Get-Closure ([double]$Number)

{

{param([double]$Sum) return $script:Number *= $Sum}.GetNewClosure()

}

for ($i = 1; $i -lt 11; $i++)

{

}

}

{{Out}}

<pre>

10 100

</pre>

$numbers = 1..20 | Get-Random -Count 10

 

}

}

{{Out}}

<pre>

20 400

</pre>

=={{header|Prolog}}==

Works with SWI-Prolog and module '''lambda.pl''' from '''Ulrich Neumerkel'''. <br>

'''lambda.pl''' can be found there : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

 

 

 

call(F, R),

format('Func ~w : ~w~n', [N, R]).

{{out}}

<pre> ?- closure.

true.

</pre>

=={{header|Python}}==

The naive way does not work:

for i in range(10):

funcs.append(lambda: i * i)

 

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 <code>foo=foo</code> 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.

for i in range(10):

funcs.append(lambda i=i: i * i)

or equivalently the list comprehension:

 

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.

for i in range(10):

funcs.append((lambda i: lambda: i * i)(i))

or equivalently the list comprehension:

 

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

 

It is also possible to use <code>eval</code>.

 

=={{header|R}}==

 

what you expect.

 

# assign 's' a list of ten functions

s <- sapply (1:10, # integers 1..10 become argument 'x' below

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.

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) {

s[[1]]()

[1] 4 # now 2^2

 

As shown, each instance increments separately.

 

=={{header|Racket}}==

#lang racket

(define functions (for/list ([i 10]) (λ() (* i i))))

(map (λ(f) (f)) functions)

{{out}}

'(0 1 4 9 16 25 36 49 64 81)

 

=={{header|REXX}}==

 

 

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

</pre>

=={{header|Ring}}==

x = funcs(7)

see x + nl

next

return fn

Output:

<pre>

49

</pre>

=={{header|Ruby}}==

 

In Ruby, lambdas (and procs) are closures.

=={{header|Rust}}==

One note here about referencing values and capturing values: <br>

Rust employs strong ownership rules that do not allow mutating a value that is referenced (pointed to without allowing mutation) from elsewhere. It also doesn't allow referencing a value that may be dropped before the reference is released. The proof that we really did capture the value is therefore unnecessary. Either we did or it wouldn't have compiled.

 

let fs: Vec<_> = (0..10).map(|i| {move || i*i} ).collect();

println!("7th val: {}", fs[7]());

 

{{out}}

<pre>7th val: 49</pre>

=={{header|Scheme}}==

 

(define (build-list-of-functions n i list)

(if (< i n)

(map (lambda (f) (f)) list-of-functions)

 

 

{{out}}

 

----

 

Using Scheme [http://srfi.schemers.org/srfi-1/srfi-1.html SRFI 1] ''iota'' procedure can be simplified to:

(define list-of-functions (map (lambda (x) (lambda () (* x x))) (iota 0 1 10)))

 

(map (lambda (n) (n)) list-of-functions)

(newline)

=={{header|Sidef}}==

 

{{out}}

<pre>

 

Starting from i=1:

func(j){i * j}

}

 

{{out}}

<pre>

81

</pre>

=={{header|Smalltalk}}==

{{out}}

<pre>9</pre>

=={{header|Sparkling}}==

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

 

for var i = 0; i < 10; i++ {

fnlist[i] = function() {

 

print(fnlist[3]()); // prints 9

 

Alternately:

 

return function() {

return v * v;

 

print(fnlist[3]()); // prints 9

=={{header|Swift}}==

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

for var i = 0; i < 10; i++ {

funcs.append({ i * i })

}

 

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

for i in 0..<10 {

funcs.append({ i * i })

}

 

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

for var i = 0; i < 10; i++ {

funcs.append({ [i] in i * i })

}

 

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

=={{header|Tcl}}==

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

# Builds a value-capturing closure; does NOT couple variables

proc closure {script} {

set idx [expr {int(rand()*9)}]; # pick random int from [0..9)

puts $idx=>[{*}[lindex $theClosures $idx]]

{{out}}

<pre>

8=>64

</pre>

=={{header|TXR}}==

 

====Sugared====

 

 

{{out}}

 

 

====Desugared====

The explicit <code>lambda</code> structure here is much like the implicit ones in the "Sugared" example:

 

;; (not implemented in original Elisp either).

(mapcar 'call

(mapcar (lambda ()

 

====Delimited Continuations====

 

Whenever we call a continuation, the <code>(block sqr ...)</code> environment is restored. and the suspended computation inside the block resumes by returning out of the <code>(suspend ...)</code> form normally. The block then executes to completion, returning the <code>(* cap cap)</code> form's value. At that point, our call to the continuation terminates, yielding that value.

 

=={{header|zkl}}==

Create a closure of the index over a square function

list:=(0).pump(10,List,fcn(i){i*i}.fp);

foreach n in (list.len()-1) { list[n]().println() }

{{out}}

<pre>

L(0,1,4,9,16,25,36,49,64,81)

</pre>

{{omit from|BASIC}}

{{omit from|Brlcad}}

{{omit from|PureBasic}}

{{omit from|ZX Spectrum Basic}}