Apply a callback to an array: Difference between revisions

** Amd-64bit-3500+-WinXP

for(i = 0; i < len; i++)

'''Language Version:''' 2.0+

==[[C plus plus|C++]]==

std::for_each(ary,ary+5,print_square);

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

(map-into *a* #'1+ *a*)

-rot cells bounds do i @ over execute i ! cell +loop ;

data 5 ' 1+ map \ adds one to each element of data

& square: <1,2,3,4,5>

== [[Haskell]] ==

[[Category:Haskell]]

'''Interpreter''' : [[GHC | GHCi]]

'''Compiler''' : [[GHC]]

let square x = x*x

let values = [1..10]

map square values

Using list comprehension to generate a list of the squared values

[square x | x <- values]

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

let printSquares = putStr.unlines.map (show.square)

printSquares values

== [[IDL]] ==

[[Category: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

b = a^3

will yield a scalar if a is scalar or a vector if a is a vector or an n-dimensional array is a is an n-dimensional array

== [[JavaScript]] ==

[[Category:JavaScript]]

Portable technique:

function map(a, func) {

for (var i in a)

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

}

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

map(a, function(v) { return v * v; });

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

var a = (1).to(10).collect(Math.pow.curry(undefined,2));

With Firefox 2.0:

function cube(num) {

return Math.pow(num, 3);

}

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

//get results of calling cube on every element

var cubes1 = numbers.map(cube);

//display each result in a separate dialog

cubes1.forEach(alert);

//array comprehension

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

var cubes3 = [n * n * n for each (n in numbers)];

==[[Lua]]==

[[Category:Lua]]

Say we have an array:

myArray = {1, 2, 3, 4, 5}

A map function for this would be

map = function(f, data)

local result = {}

for k,v in ipairs(data) do

result[k] = f(v)

end

return result

end

Together with our array and and a square function this yields:

myFunc = function(x) return x*x end

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

--> 1 4 9 16 25

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

== [[OCaml]] ==

[[Category:OCaml]]

This function is part of the standard library:

Array.map

Usage example:

let square x = x * x;;

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

Array.map square values;;

==[[Perl]]==

[[Category:Perl]]

# create array

my @a = (1, 2, 3, 4, 5);

# create callback function

sub mycallback {

return 2 * shift;

}

# use array indexing

my $i;

for ($i = 0; $i < scalar @a; $i++) {

print "mycallback($a[$i]) = ", mycallback($a[$i]), "\n";

}

# using foreach

foreach my $x (@a) {

print "mycallback($x) = ", mycallback($x), "\n";

}

# using map (useful for transforming an array)

my @b = map mycallback($_), @a; # @b is now (2, 4, 6, 8, 10)

# and the same using an anonymous function

my @c = map { $_ * 2 } @a; # @c is now (2, 4, 6, 8, 10)

# use a callback stored in a variable

my $func = \&mycallback;

my @d = map &{$func}($_), @a; # @d is now (2, 4, 6, 8, 10)

==[[PHP]]==

[[Category:PHP]]

function cube($n)

{

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

}

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

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

print_r($b);

== [[PL/SQL]] ==

[[Category:PL/SQL]]

'''Interpreter''' : Oracle compiler

set serveroutput on

declare

type myarray is table of number index by binary_integer;

x myarray;

i pls_integer;

begin

-- populate array

for i in 1..5 loop

x(i) := i;

end loop;

i :=0;

-- square array

loop

i := i + 1;

begin

x(i) := x(i)*x(i);

dbms_output.put_line(x(i));

exception

when no_data_found then exit;

end;

end loop;

end;

/

==[[Pop11]]==

[[Category:Pop11]]

;;; Define a procedure

define proc(x);

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

enddefine;

;;; Create array

lvars ar = { 1 2 3 4 5};

;;; Apply procedure to array

appdata(ar, proc);

If one wants to create a new array consisting of transformed values

then procedure mapdata may be more convenient.

== [[Python]] ==

[[Category:Python]]

<pre>

def square(n):

return n * n

numbers = [1, 3, 5, 7]

squares1 = [square(n) for n in numbers] # list comprehension

squares2 = map(square, numbers) # discouraged nowadays

squares3 = [n * n for n in numbers] # no need for a function,

# anonymous or otherwise

isquares = (n * n for n in numbers) # iterator, lazy

</pre>

==[[Ruby]]==

[[Category:Ruby]]

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

for i in [1,2,3,4,5] do

puts i**2

end

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

[1,2,3,4,5].each{ |i| puts i**2 }

# To create a new array of each value squared

[1,2,3,4,5].map{ |i| i**2 }

==[[Scala]]==

[[Category:Scala]]

val l = List(1,2,3,4)

l.foreach {i => Console.println(i)}

Same for an array

val a = Array(1,2,3,4)

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

// Or for an externally defined function

def doSomething(in: int) = {Console.println("Doing something with "+in)}

l.foreach(doSomething)

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

for(val i <- a) Console.println(i)

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)

val squares = l.map{i => i * i} //returns List(1,4,9,16)

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

val squares = for (val i <- l) yield i * i

== [[Scheme]] ==

[[Category:Scheme]]

(define (square n) (* n n))

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

(map square x)

''Please fix: '(1 2 3 4 5) is a list, not a vector''

A single-line variation

(map (lambda (n) (* n n)) '(1 2 3 4 5))

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

(define (map f L)

(if (null? L)

L

(cons (f (car L)) (map f (cdr L)))))

== [[Smalltalk]] ==

[[Category:Smalltalk]]

| anArray |

anArray = #( 1 2 3 4 5 )

anArray do: [ :x | Transcript nextPut: x * x ]

== [[Tcl]] ==

[[Category:Tcl]]

If I wanted to call "<tt>myfunc</tt>" on each element of <tt>dat</tt> and <tt>dat</tt> were a list:

foreach var $dat { myfunc $var }

if <tt>dat</tt> were an array, however:

foreach var [array names dat] { myfunc $dat($var) }

== [[Toka]] ==

[[Category:Toka]]

( array count function -- )

{

variable| array fn |

[ i 1- array @ ] is I

[ fn ! swap array ! [ I get-element fn @ invoke I put-element ] +iterate ]

} is map-array

( Build an array )

5 cells is-array a

10 0 a put-element

11 1 a put-element

12 2 a put-element

13 3 a put-element

14 4 a put-element

( Add 1 to each item in the array )

a 5 ` 1+ map-array