Closures/Value capture: Difference between revisions

{{task}}

 

 

=={{header|Axiom}}==

Using the Spad compiler:

TestPackage() : with

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

== add

 

This can be called from the interpreter using:

 

 

=={{header|Babel}}==

 

{ iter

1 take bons 1 take

10 times

collect !

 

81

64

9

4

 

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

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;

 

 

<pre>$ ./a.out

81

0

</pre>

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

===Using Linq===

using System.Linq;

 

}

}

1

4

36

49

 

===Using delegates only===

 

using System;

using System.Collections.Generic;

}

}

1

4

36

49

 

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

 

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

{

}

}

 

<pre>

Function at index: 7 outputs 49

</pre>

 

=={{header|Go}}==

 

import "fmt"

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

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

<pre>

func #0: 0

func #3: 9

</pre>

=={{header|Groovy}}==

Solution:

 

Test:

assert closures.size() == 10

closures.each { assert it instanceof Closure }

 

<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 vcapture(x) # vcapture closes over its argument

end

 

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

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

 

{{libheader|Unicon Code Library}}

[https://tapestry.tucson.az.us/twiki/bin/view/Main/AnonymousFunctions Summary of Anonymous Functions in Unicon]

 

 

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

 

 

 

3"_

slist @.3

 

 

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"

}

 

=={{header|JavaScript}}==

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"

 

=={{header|Julia}}==

<pre>

julia> funcs[7]()

49

</pre>

 

=={{header|Logtalk}}==

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

:- object(value_capture).

 

 

:- end_object.

| ?- value_capture::show.

Closure 1 : 1

Closure 10 : 100

yes

=={{header|Lua}}==

funcs={}

for i=1,10 do

funcs[2]()

funcs[3]()

<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

->{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]())");

}

<pre>16

4</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) ());

 

<pre>

fun.(4) = 16

fun.(6) = 36

</pre>

 

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

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

 

<pre>%1 = 25</pre>

=={{header|Perl}}==

0

1

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|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]).

<pre> ?- closure.

Func 1 : 1

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

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

 

=={{header|REXX}}==

 

 

</pre>

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

 

=={{header|Scheme}}==

 

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

(if (< i n)

list))

 

 

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

 

 

 

 

1

4

49

64

 

=={{header|Smalltalk}}==

<pre>9</pre>

 

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

<pre>

5=>25

8=>64

</pre>

 

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