Apply a callback to an array: Difference between revisions

 

=={{header|ActionScript}}==

{

public class ArrayCallback

}

}

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2005}}

with Ada.Integer_text_IO;

begin

Map(Sample, Display'access);

 

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

Output:

 

=={{header|AutoHotkey}}==

callback(array)

{

{

%callback%(array)

 

 

=={{header|AWK}}==

 

=={{header|C}}==

 

{{works with|Visual C sharp|Visual C#|2005}}

 

static class Program

Console.WriteLine(value * value);

}

 

{{works with|C sharp|C#|3.0+}}

This version uses the C# 3 lambda notation.

 

 

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

{{works with|g++|4.1.1}}

===C-Style Array===

#include <algorithm> //for_each defined here

 

return 0;

}

 

===std::vector===

{{libheader|STL}}

#include <algorithm> // for_each defined here

#include <vector> // stl vector class

return 0;

}

 

More tricky with binary function

#include <algorithm> // for_each defined here

#include <vector> // stl vector class

return 0;

}

 

===Boost.Lambda===

{{libheader|Boost}}

using namespace boost::lambda;

vector<int> ary(10);

int i = 0;

for_each(ary.begin(), ary.end(), _1 = ++var(i)); // init array

 

=={{header|Clean}}==

Define a function and an initial (unboxed) array.

 

 

values :: {#Int}

 

One can easily define a map for arrays, which is overloaded and works for all kinds of arrays (lazy, strict, unboxed).

 

 

Apply the function to the initial array (using a comprehension) and print result.

 

 

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

Imperative: print 1, 2, 3, 4 and 5:

 

 

Functional: collect squares into new vector that is returned:

 

 

Destructive, like the Javascript example; add 1 to every slot of vector *a*:

 

 

=={{header|Clojure}}==

 

 

 

 

=={{header|D}}==

auto result = new U[array.length];

[1, 2, 3, 4, 5].map( (int i) { return i+5; } )

);

Using std.algorithm:

 

=={{header|E}}==

 

def square(value) {

return value * value

 

Example of builtin iteration:

 

println(`Item $index is $value.`)

}

 

There is no built-in map function '''yet'''. The following is one of the ways one could be implemented, returning a plain list (which is usually an array in implementation).

 

def output := [].diverge()

for item in collection {

return output.snapshot()

}

 

=={{header|Forth}}==

This is a word that will call a given function on each cell in an array.

 

 

Example usage:

 

 

=={{header|Fortran}}==

 

{{Works with |Fortran|ISO 95 and later}}

contains

elemental function cube( x )

cube = x * x * x

end function cube

 

use arrCallback

implicit none

write(*,*) b(i,:)

end do

 

{{Works with|ANSI FORTRAN| 77 (with MIL-STD-1753 structured DO) and later}}

C

C-- Declare array:

end do

C

 

=={{header|FP}}==

 

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

Apply a named function to each member of the array. The result is a new array of the same size as the input.

The same can be done using anonymous functions, this time squaring the members of the input array.

 

=={{header|Groovy}}==

 

Print each value in a list

 

Create a new list containing the squares of another list

 

=={{header|Haskell}}==

===List===

{{works with|GHC}}

let values = [1..10]

 

Using list comprehension to generate a list of the squared values

 

Using function composition to create a function that will print the squares of a list

 

===Array===

{{works with|GHC}}

let square x = x*x

let values = array (1,10) [(i,i)|i <- [1..10]] :: Array Int Int

 

=={{header|Icon}}==

local lst

lst := [10, 20, 30, 40]

procedure callback(arg)

write("->", arg)

 

=={{header|IDL}}==

Hard to come up with an example that isn't completely contrived. IDL doesn't really distinguish between a scalar and an array; thus

 

 

will yield a scalar if <tt>a</tt> is scalar or a vector if <tt>a</tt> is a vector or an n-dimensional array if <tt>a</tt> is an n-dimensional array

 

=={{header|Io}}==

 

=={{header|J}}==

So if you want to perform an action (which doesn't return anything) on an array of int's:

 

void run(int x);

}

}

}.run(z);

 

Or if you want to perform "map" - return an array of the results of function applications:

 

int run(int x);

}

}

}.run(myIntArray[i]);

 

=={{header|JavaScript}}==

Portable technique:

 

for (var i in a)

a[i] = func(a[i]);

 

var a = [1, 2, 3, 4, 5];

 

{{libheader|BeyondJS}}

With the [http://w3future.com/html/beyondJS/ BeyondJS] library:

 

 

With Firefox 2.0:

 

return Math.pow(num, 3);

}

// array comprehension

var cubes2 = [cube(n) for each (n in numbers)];

 

{{libheader|Functional}}

 

=={{header|Joy}}==

 

=={{header|Lisaac}}==

+ b : BLOCK;

 

};

 

 

=={{header|Logo}}==

output :x * :x

end

show map "square [1 2 3 4 5] ; [1 4 9 16 25]

show map [? * ?] [1 2 3 4 5] ; [1 4 9 16 25]

 

=={{header|Lua}}==

 

Say we have an array:

A map function for this would be

local result = {}

for k,v in ipairs(data) do

end

return result

Together with our array and a square function this yields:

 

print(unpack( map(myFunc, myArray) ))

If you used pairs() instead of ipairs(), this would even work on a hash table in general.

 

=={{header|M4}}==

define(`_arg1', `$1')dnl

define(`_foreach', `ifelse(`$2', `()', `',

dnl

define(`z',`eval(`$1*2') ')dnl

 

Output:

=={{header|Nial}}==

 

 

=={{header|OCaml}}==

This function is part of the standard library:

 

 

Usage example:

let values = Array.init 10 ((+) 1);;

 

=={{header|Octave}}==

 

=={{header|Oz}}==

import

Application System

 

{Application.exit 0}

=={{header|Perl}}==

<lang perl># create array

 

=={{header|PHP}}==

{

return($n * $n * $n);

$a = array(1, 2, 3, 4, 5);

$b = array_map("cube", $a);

 

=={{header|PL/SQL}}==

{{works with|Oracle}}

declare

type myarray is table of number index by binary_integer;

 

end;

 

=={{header|Pop11}}==

 

define proc(x);

printf(x*x, '%p,');

 

;;; Apply procedure to array

 

If one wants to create a new array consisting of transformed values then procedure mapdata may be more convenient.

 

=={{header|Python}}==

return n * n

 

import itertools

To print squares of integers in the range from 0 to 9, type:

Or:

Result:

 

=={{header|R}}==

Many functions can take advantage of implicit vectorisation, e.g.

elements <- 1:5

Explicit looping over array elements is also possible.

for(i in seq_along(cubes))

{

cubes[i] <- cube(elements[i])

Loop syntax can often simplified using the [http://stat.ethz.ch/R-manual/R-patched/library/base/html/apply.html *array] family of functions.

In each case above, the value of 'cubes' is

1 8 27 64 125

 

=={{header|Raven}}==

 

group [1 2 3 4 5] each

dup *

 

=={{header|Ruby}}==

You could use a traditional "for i in arr" approach like below:

puts i**2

 

Or you could the more preferred ruby way of an iterator (which is borrowed from SmallTalk)

 

To create a new array of each value squared

 

=={{header|Scala}}==

 

When the argument appears only once -as here, i appears only one in println(i) - it may be shortened to

Same for an array

a.foreach {i => println(i)}

 

Or for an externally defined function:

 

There is also a ''for'' syntax, which is internally rewritten to call foreach. A foreach method must be defined on ''a''

 

It is also possible to apply a function on each item of an list to get a new list (same on array and most collections)

 

Or the equivalent ''for'' syntax, with the additional keyword ''yield'', map is called instead of foreach

 

=={{header|Scheme}}==

(define x #(1 2 3 4 5))

 

A single-line variation

 

For completeness, the <tt>map</tt> function (which is R5RS standard) can be coded as follows:

(if (null? L)

L

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

=={{header|Tcl}}==

 

=={{header|TI-89 BASIC}}==

 

Define foreach(fe_cname,fe_list) = Prgm

Local fe_i

 

foreach("callback", {1,2,3,4,5})

 

Output:

=={{header|Toka}}==

 

 

 

The * is a built-in map operator.

This example shows a map of the successor function over a list of natural numbers.

 

#cast %nL

 

output:

<pre>

=={{header|V}}==

apply squaring (dup *) to each member of collection

 

=={{header|Vorpal}}==

Given and array, A, and a function, F, mapping F over the elements of A is simple:

If F takes 2 arguments, x and , then simply pass them to map. They will be passed to F when as it is applied to each element of A.

 

{{omit from|gnuplot}}