Closures/Value capture: Difference between revisions

{{task}}

 

 

See also: [[Multiple distinct objects]]

=={{header|11l}}==

<syntaxhighlight lang="11l">[(() -> Int)] funcs

9

</pre>

=={{header|Ada}}==

 

{{out}}

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

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

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

 

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

<syntaxhighlight lang="AntLang">fns: {n: x; {n expt 2}} map range[10]

(8 elem fns)[]</syntaxhighlight>

=={{header|AppleScript}}==

{{trans|JavaScript}}

{{Out}}

<pre>9</pre>

=={{header|Axiom}}==

Using the Spad compiler:

<syntaxhighlight lang="Axiom">[1,4,9,16,25,36,49,64,81,100]

Type: List(Integer)</syntaxhighlight>

=={{header|Babel}}==

 

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

<syntaxhighlight lang="bracmat">( -1:?i

49

64</pre>

=={{header|C}}==

 

0

</pre>

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

===Using Linq===

49

64</syntaxhighlight>

=={{header|C++}}==

{{works with|C++11}}

81

</pre>

=={{header|Ceylon}}==

<syntaxhighlight lang="ceylon">shared void run() {

}

}</syntaxhighlight>

=={{header|Clojure}}==

<syntaxhighlight lang="clojure">(def funcs (map #(fn [] (* % %)) (range 11)))

<pre>9

16</pre>

=={{header|CoffeeScript}}==

 

console.log func() for func in funcs

</syntaxhighlight>

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

<syntaxhighlight lang="lisp">CL-USER> (defparameter 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===

{{out}}

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

=={{header|Delphi}}==

{{works with|Delphi 2009}}

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:

 

This is similar to a JavaScript (ES6) solution.

=={{header|EchoLisp}}==

<syntaxhighlight lang="scheme">

→ 25

</syntaxhighlight>

=={{header|Elena}}==

ELENA 4.1 :

64

81</pre>

=={{header|Elixir}}==

<syntaxhighlight lang="elixir">funs = for i <- 0..9, do: (fn -> i*i end)

81

</pre>

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

As of Emacs 24.3, lexical closures are supported, therefore alleviating hacks such as lexical-let.

'(1 2 3 4 5 6 7 8 9 10)))

;; => (1 4 9 16 25 36 49 64 81 100)</syntaxhighlight>

=={{header|Erlang}}==

Erlang uses lexical scoping and has anonymous functions.

ok

</pre>

=={{header|F_Sharp|F#}}==

Nearly identical to OCaml

81

</pre>

=={{header|Factor}}==

===Using lexical variables===

] each

drop</syntaxhighlight>

=={{header|Fantom}}==

 

Function at index: 7 outputs 49

</pre>

=={{header|Forth}}==

<syntaxhighlight lang="forth">: xt-array here { a }

 

<syntaxhighlight lang="forth">25</syntaxhighlight>

=={{header|FreeBASIC}}==

 

81

</pre>

=={{header|Go}}==

<syntaxhighlight lang="go">package main

func #3: 9

</pre>

=={{header|Groovy}}==

Solution:

{{out}}

<pre>49</pre>

=={{header|Haskell}}==

 

> fs !! 8 $ undefined

81</syntaxhighlight>

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

{{out}}

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

=={{header|Io}}==

<syntaxhighlight lang="text">blist := list(0,1,2,3,4,5,6,7,8,9) map(i,block(i,block(i*i)) call(i))

writeln(blist at(3) call) // prints 9</syntaxhighlight>

=={{header|J}}==

 

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

25</syntaxhighlight>

=={{header|Java}}==

{{works with|Java|8+}}

}

}</syntaxhighlight>

=={{header|JavaScript}}==

 

9

</pre>

=={{header|Julia}}==

<syntaxhighlight lang="julia">funcs = [ () -> i^2 for i = 1:10 ]</syntaxhighlight>

49

</pre>

=={{header|Kotlin}}==

<syntaxhighlight lang="scala">// version 1.0.6

64

</pre>

=={{header|Lambdatalk}}==

 

-> 16

</syntaxhighlight>

=={{header|Latitude}}==

 

64

81</pre>

=={{header|LFE}}==

 

 

</syntaxhighlight>

=={{header|Lingo}}==

 

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

-- 64</syntaxhighlight>

=={{header|Logtalk}}==

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

yes

</syntaxhighlight>

=={{header|Lua}}==

<syntaxhighlight lang="Lua">

9

</pre>

=={{header|M2000 Interpreter}}==

<syntaxhighlight lang="M2000 Interpreter">

 

</syntaxhighlight>

=={{header|Maple}}==

<syntaxhighlight lang="Maple">> L := map( i -> (() -> i^2), [seq](1..10) ):

16

</syntaxhighlight>

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

<syntaxhighlight lang="Mathematica">Function[i, i^2 &] /@ Range@10

%[[2]][]

->4</syntaxhighlight>

=={{header|Nemerle}}==

<syntaxhighlight lang="Nemerle">using System.Console;

<pre>16

4</pre>

=={{header|Nim}}==

<syntaxhighlight lang="nim">var funcs: seq[proc(): int] = @[]

for i in 0..8:

echo "func[", i, "]: ", funcs[i]()</syntaxhighlight>

=={{header|Objeck}}==

<syntaxhighlight lang="objeck">use Collection.Generic;

81

</pre>

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

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

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

</syntaxhighlight>

=={{header|OCaml}}==

 

fun.(6) = 36

</pre>

=={{header|Oforth}}==

<syntaxhighlight lang="Oforth">: newClosure(i) #[ i sq ] ;

49

</pre>

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

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

{{out}}

<pre>%1 = 25</pre>

=={{header|Perl}}==

<syntaxhighlight lang="perl">my @f = map(sub { $_ * $_ }, 0 .. 9); # @f is an array of subs

64

</pre>

=={{header|Phix}}==

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

<!--</syntaxhighlight>-->

same output, for both tests

=={{header|Phixmonti}}==

<syntaxhighlight lang="Phixmonti">def power2

i get i swap exec print " " print

endfor</syntaxhighlight>

=={{header|PHP}}==

{{works with|PHP|5.3+}}

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

?></syntaxhighlight>

=={{header|PicoLisp}}==

<syntaxhighlight lang="PicoLisp">(setq FunList

: ((get FunList 8))

-> 64</pre>

=={{header|Pike}}==

<syntaxhighlight lang="Pike">array funcs = ({});

});

}</syntaxhighlight>

=={{header|PowerShell}}==

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

20 400

</pre>

=={{header|Prolog}}==

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

true.

</pre>

=={{header|Python}}==

The naive way does not work:

<syntaxhighlight lang="python">funcs=[eval("lambda:%s"%i**2)for i in range(10)]

print funcs[3]() # prints 9</syntaxhighlight>

=={{header|Quackery}}==

 

 

<pre>25</pre>

=={{header|R}}==

 

[1] 16

</pre>

=={{header|Racket}}==

<syntaxhighlight lang="racket">

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

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

Or equivalently, using a more functional notation:

<syntaxhighlight lang="raku" line>say .() for pick *, map -> $i { -> {$i * $i} }, ^10</syntaxhighlight>

=={{header|Red}}==

<syntaxhighlight lang="Red">

== 49

</syntaxhighlight>

=={{header|REXX}}==

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

function .0 returned 100

</pre>

=={{header|Ring}}==

<syntaxhighlight lang="ring">

49

</pre>

=={{header|Ruby}}==

<syntaxhighlight lang="ruby">procs = Array.new(10){|i| ->{i*i} } # -> creates a lambda

 

In Ruby, lambdas (and procs) are closures.

=={{header|Rust}}==

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

{{out}}

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

=={{header|Scala}}==

<syntaxhighlight lang="scala">val closures=for(i <- 0 to 9) yield (()=>i*i)

---

49</pre>

=={{header|Scheme}}==

 

(newline)

</syntaxhighlight>

=={{header|Sidef}}==

<syntaxhighlight lang="ruby">var f = (

81

</pre>

=={{header|Smalltalk}}==

<syntaxhighlight lang="smalltalk">funcs := (1 to: 10) collect: [ :i | [ i * i ] ] .

{{out}}

<pre>9</pre>

=={{header|Sparkling}}==

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

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

print(fnlist[5]()); // prints 25</syntaxhighlight>

=={{header|Standard ML}}==

<syntaxhighlight lang="Standard ML">

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

</syntaxhighlight>

=={{header|Swift}}==

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

<syntaxhighlight lang="swift">let funcs = [] + map(0..<10) {i in { i * i }}

println(funcs[3]()) // prints 9</syntaxhighlight>

=={{header|Tcl}}==

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

8=>64

</pre>

=={{header|TXR}}==

 

 

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

<syntaxhighlight lang="ecmascript">var fs = List.filled(10, null)

Function #8: 64

</pre>

=={{header|Yabasic}}==

<syntaxhighlight lang="Yabasic">

next

</syntaxhighlight>

=={{header|zkl}}==

Create a closure of the index over a square function

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