Apply a callback to an array: Difference between revisions

 

=={{header|ActionScript}}==

package

{

}

}

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2005}}

with Ada.Text_Io;

with Ada.Integer_text_IO;

Map(Sample, Display'access);

end Call_Back_Example;

 

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

{{works with|ICC|9.1}}

===callback.h===

#ifndef CALLBACK_H

#define CALLBACK_H

 

#endif

 

===callback.c===

#include <stdio.h>

#include "callback.h"

return 0;

}

 

===Output===

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

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

 

 

{{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 <iostream> //cout for printing

#include <algorithm> //for_each defined here

}

//prints 1 4 9 16 25

 

===std::vector===

{{libheader|STL}}

#include <iostream> // cout for printing

#include <algorithm> // for_each defined here

}

//prints 1 4 9 16 25

 

More tricky with binary function

#include <iostream> // cout for printing

#include <algorithm> // for_each defined here

}

//prints 1x 2x 3x 4x 5x

 

===Boost.Lambda===

{{libheader|Boost}}

using namespace std;

using namespace boost::lambda;

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

transform(ary.begin(), ary.end(), ostream_iterator<int>(cout, " "), _1 * _1); // square and output

 

=={{header|Clean}}==

Define a function and an initial (unboxed) array.

 

 

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:

 

(map nil #'print #(1 2 3 4 5))

 

Functional: collect squares into new vector that is returned:

 

(defun square (x) (* x x))

(map 'vector #'square #(1 2 3 4 5))

 

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

 

(defvar *a* (vector 1 2 3))

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

 

=={{header|Clojure}}==

 

 

 

 

=={{header|D}}==

U[] map(T, U)(T[] array, U delegate(T) dg) {

auto result = new U[array.length];

);

}

Using std.algorithm:

writefln(map!("a + 5")([1, 2, 3, 4, 5]));

 

=={{header|E}}==

 

 

Example of builtin iteration:

 

 

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

 

 

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

module arrCallback

contains

end function cube

end module arrCallback

 

program testAC

use arrCallback

end do

end program testAC

 

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

C

C-- Declare array:

C

end

 

=={{header|FP}}==

 

Print each value in a list

[1,2,3,4].each { println it }

 

Create a new list containing the squares of another list

[1,2,3,4].collect { it * it }

 

=={{header|Haskell}}==

===List===

{{works with|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

 

===Array===

{{works with|GHC}}

import Data.Array.IArray

let square x = x*x

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

amap square values

 

=={{header|Icon}}==

 

 

=={{header|IDL}}==

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

 

interface IntToVoid {

void run(int x);

}.run(z);

}

 

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

 

interface IntToInt {

int run(int x);

}.run(myIntArray[i]);

}

 

=={{header|JavaScript}}==

Portable technique:

 

function map(a, func) {

for (var i in a)

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

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

 

{{libheader|BeyondJS}}

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];

 

var cubes1 = numbers.map(cube);

 

cubes1.forEach(alert);

 

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

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

 

{{libheader|Functional}}

Functional.map('x*x*x', [1,2,3,4,5])

=={{header|Logo}}==

 

=={{header|Lua}}==

 

Say we have an array:

A map function for this would be

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

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

 

=={{header|Nial}}==

 

each (* [first, first] ) 1 2 3 4

=1 4 9 16

 

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

 

=={{header|Oz}}==

functor

import

{Application.exit 0}

end

=={{header|Perl}}==

# create array

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

my $func = \&mycallback;

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

 

=={{header|PHP}}==

function cube($n)

{

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

print_r($b);

 

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

{{works with|Oracle}}

set serveroutput on

declare

end;

/

 

=={{header|Pop11}}==

 

 

 

 

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

 

=={{header|Python}}==

def square(n):

return n * n

import itertools

isquares2 = itertools.imap(square, numbers) # iterator, lazy

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

print " ".join(str(n * n) for n in range(10))

Or:

print " ".join(map(str, map(square, range(10))))

Result:

0 1 4 9 16 25 36 49 64 81

 

=={{header|Raven}}==

 

 

 

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

 

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

 

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 (square n) (* n n))

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

(map square (vector->list x))

 

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

 

=={{header|Smalltalk}}==

#( 1 2 3 4 5 ) collect: [:n | n * n].

=={{header|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 name [array names dat] { myfunc $dat($name) }

 

=={{header|Toka}}==

 

( array count function -- )

{

( Add 1 to each item in the array )

a 5 [ 1 + ] map-array

 

=={{header|V}}==

apply squaring (dup *) to each member of collection

[1 2 3 4] [dup *] map