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 |λ|

end script

{{Out}}

<pre>9</pre>

Or, in a more functional pattern of composition:

 

 

script closure

end script

end if

{{Out}}

<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|C++}}==

{{works with|C++11}}

#include <functional>

#include <vector>

std::cout << f( ) << std::endl ;

return 0;

{{out}}

<pre>0

81

</pre>

=={{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|Dyalect}}==

Dyalect captures variables by reference, therefore a way to achieve this is to capture a variable through a closure which in its turn returns a anonymous function like so:

 

let num = 10

 

for n in 0..<num {

}

 

for x in xs {

print(x())

 

{{out}}

 

This is similar to a JavaScript (ES6) solution.

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

import extensions;

public program()

{

{{out}}

<pre>0

 

=={{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|FreeBASIC}}==

 

FreeBASIC doesn't support closures or anonymous methods, as such. However, what we can do is to create an array of objects to capture their index and then call a method on those objects which squares the index. This approach is similar to how some other object oriented languages implement closures 'under the hood'.

 

 

Type Closure

Print

Print "Press any key to quit"

 

{{out}}

81

</pre>

=={{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|Kotlin}}==

 

fun main(args: Array<String>) {

// call all but the last

(0 .. 8).forEach { println(funcs[it]()) }

 

{{out}}

64

</pre>

=={{header|Lambdatalk}}==

 

A translation from Javascript

{def A

{A.new

{A.get 4 {A}}

-> 16

=={{header|Latitude}}==

 

Latitude is particularly well suited to this challenge, as the various iteration constructs actually take method arguments and <i>call</i> them multiple times. Thus, the loop variable is in fact an argument which is already closed over and distinct at each iteration.

 

takes '[i].

proc { (i) * (i). }.

}.

 

 

{{Out}}

64

81</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|Lingo}}==

 

Lingo doesn't really support closures. But with the limitations described at [https://www.rosettacode.org/wiki/Function_composition#Lingo Function composition] and based on the fact that Lingo allows to create arbitrary code at runtime, the task can be solved like this:

 

 

property _code

do(me._code)

return res

 

repeat with i = 1 to 10

code = "res="&i&"*"&i

 

put call(funcs[3], _movie)

 

Since the original task is a little trivial in terms of not depending on runtime arguments, here also a solution for an extended task: let each function[i] return the square of i plus the sum of all arguments passed to it at runtime:

 

repeat with i = 1 to 10

code = ""

 

put call(funcs[7], _movie, 4, 5, 6)

=={{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|M2000 Interpreter}}==

Dim Base 0, A(10)

For i=0 to 9 {

Print a(i)()

}

Print

0

 

Export list to clipboard

document a$

For i=0 to 9 {

}

Clipboard a$

 

Using Inventory, and a stack object (reading from position, and another way, we pop functions, using Read)

 

 

Inventory Alfa

For i=0 to 9 {

}

 

=={{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|Objeck}}==

 

class Capture {

}

}

 

{{output}}

81

</pre>

=={{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|Phix}}==

Phix does not support closures, but they seem easy enough to emulate

{{out}}

<pre>

 

A dictionary based approach may prove somewhat easier:

same output, for both tests

=={{header|Phixmonti}}==

dup *

enddef

var i

i get i swap exec print " " print

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

I think that modifying the bound variable can be done in a simpler way.

Instead of:

substitute:

Testing:

<pre>

[1] 16

</pre>

=={{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|Raku}}==

(formerly Perl 6)

{{Works with|Rakudo|2015.12}}

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

take { $i * $i }

}

 

{{out}}

<pre>36

49</pre>

Or equivalently, using a more functional notation:

=={{header|Red}}==

funs: collect [repeat i 10 [keep func [] reduce [i ** 2]]]

 

>> funs/7

== 49

=={{header|REXX}}==

This REXX version supports both a one─ and zero─based list &nbsp; (it can be specified at the command line.)

 

No error checking is performed on the user input(s).

parse arg seed base $ /*obtain optional arguments from the CL*/

if datatype(seed, 'W') then call random ,,seed /*Not given? Use random start seed. */

.9: return .(9) /* ' .9 " " " " */

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

{{out|output|text=&nbsp; when using the default input &nbsp; which assume a zero─based list):}}

<pre>

function .0 returned 100

</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|Scala}}==

0 to 8 foreach (i=> println(closures(i)()))

{{out}}

<pre>0

---

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}}==

10.of {|i| func(j){i * j} }

)

9.times { |j|

say f[j](j)

{{out}}

<pre>

 

Starting from i=1:

func(j){i * j}

}

for j (1..9) {

say f[j-1](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|Standard ML}}==

List.map (fn x => x () ) ( List.tabulate (10,(fn i => (fn ()=> i*i)) ) ) ;

val it = [0,1,4,9,16,25,36,49,64,81] : int list

=={{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|Wren}}==

for (i in 0...fs.count) {

fs[i] = Fn.new { i * i }

}

 

 

{{out}}

 

=={{header|Yabasic}}==

dim funcs$(10)

 

print execute(funcs$(i), i)

next

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