Apply a callback to an array

Apply a callback to an array
You are encouraged to solve this task according to the task description, using any language you may know.

In this task, the goal is to take a combined set of elements and apply a function to each element.

ACL2

ACL2 does not have first-class functions; this is close, however:

(defun sq-each (xs)
   (if (endp xs)
       nil
       (cons (* (first xs) (first xs))
             (sq-each (rest xs)))))

ActionScript

package
{
    public class ArrayCallback
    {
        public function main():void
        {
            var nums:Array = new Array(1, 2, 3);
            nums.map(function(n:Number, index:int, arr:Array):void { trace(n * n * n); });
 
            // You can also pass a function reference
            nums.map(cube);
        }
 
        private function cube(n:Number, index:int, arr:Array):void
        {
            trace(n * n * n);
        }
    }
}

Ada

Works with: GNAT version GPL 2005

with Ada.Text_Io;
 with Ada.Integer_text_IO;
 
 procedure Call_Back_Example is
    -- Purpose: Apply a callback to an array
    -- Output: Prints the squares of an integer array to the console
 
    -- Define the callback procedure
    procedure Display(Location : Positive; Value : Integer) is
    begin
       Ada.Text_Io.Put("array(");
       Ada.Integer_Text_Io.Put(Item => Location, Width => 1);
       Ada.Text_Io.Put(") = ");
       Ada.Integer_Text_Io.Put(Item => Value * Value, Width => 1);
       Ada.Text_Io.New_Line;
    end Display;
 
    -- Define an access type matching the signature of the callback procedure
    type Call_Back_Access is access procedure(L : Positive; V : Integer);
 
    -- Define an unconstrained array type
    type Value_Array is array(Positive range <>) of Integer;
 
    -- Define the procedure performing the callback
    procedure Map(Values : Value_Array; Worker : Call_Back_Access) is
    begin
       for I in Values'range loop
          Worker(I, Values(I));
       end loop;
    end Map;
 
    -- Define and initialize the actual array
    Sample : Value_Array := (5,4,3,2,1);
 
 begin
    Map(Sample, Display'access);   
 end Call_Back_Example;

Aime

void
map(list l, void (*fp) (object))
{
    integer i;
 
    i = 0;
    while (i < l_length(l)) {
	fp(l_query(l, i));
	i += 1;
    }
}
 
 
void
out(object o)
{
    o_integer(o);
    o_byte(10);
}
 
 
integer
main(void)
{
    list l;
 
    l_append(l, 0);
    l_append(l, 1);
    l_append(l, 2);
    l_append(l, 3);
 
    map(l, out);
 
    return 0;
}

ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

 PROC call back proc = (INT location, INT value)VOID:
 (
   printf(($"array["g"] = "gl$, location, value))
 );
 
 PROC map = (REF[]INT array, PROC (INT,INT)VOID call back)VOID:
 (
   FOR i FROM LWB array TO UPB array DO
      call back(i, array[i])
   OD
 );
 
 main:
 (
   [4]INT array := ( 1, 4, 9, 16 );
   map(array, call back proc)
 )

Output:

array[         +1] =          +1
array[         +2] =          +4
array[         +3] =          +9
array[         +4] =         +16

AutoHotkey

map("callback", "3,4,5")
 
callback(array){
  Loop, Parse, array, `,
    MsgBox % (2 * A_LoopField)
}
 
map(callback, array){
  %callback%(array)
}

AWK

$ awk 'func psqr(x){print x,x*x}BEGIN{split("1 2 3 4 5",a);for(i in a)psqr(a[i])}'
4 16
5 25
1 1
2 4
3 9

Brat

#Print out each element in array
[:a :b :c :d :e].each { element |
	p element
}

Alternatively:

[:a :b :c :d :e].each ->p

C

callback.h

#ifndef CALLBACK_H
#define CALLBACK_H
 
/*
 * By declaring the function in a separate file, we allow
 * it to be used by other source files.
 *
 * It also stops ICC from complaining.
 *
 * If you don't want to use it outside of callback.c, this
 * file can be removed, provided the static keyword is prepended
 * to the definition.
 */
void map(int* array, int len, void(*callback)(int,int));
 
#endif

callback.c

#include <stdio.h>
#include "callback.h"
 
/*
 * We don't need this function outside of this file, so
 * we declare it static.
 */
static void callbackFunction(int location, int value)
{
  printf("array[%d] = %d\n", location, value);
} 
 
void map(int* array, int len, void(*callback)(int,int))
{
  int i;
  for(i = 0; i < len; i++)
  {
     callback(i, array[i]);
  }
} 
 
int main()
{
  int array[] = { 1, 2, 3, 4 };
  map(array, 4, callbackFunction);
  return 0;
}

Output

 array[0] = 1
 array[1] = 2
 array[2] = 3
 array[3] = 4

C#

Works with: C# version 2.0+

Works with: Visual C# version 2005

using System; 
 
static class Program
{
  // Purpose: Apply a callback (or anonymous method) to an Array
  // Output: Prints the squares of an int array to the console.
  // Compiler: Visual Studio 2005
  // Framework: .net 2
 
  [STAThread]
  public static void Main() 
  {
    int[] intArray = { 1, 2, 3, 4, 5 };
 
    // Using a callback,
    Console.WriteLine("Printing squares using a callback:");
    Array.ForEach<int>(intArray, PrintSquare);
 
    // or using an anonymous method:
    Console.WriteLine("Printing squares using an anonymous method:");
    Array.ForEach<int>
    (
      intArray,
      delegate(int value) 
      {
        Console.WriteLine(value * value);    
      });
  }
 
  public static void PrintSquare(int value) 
  { 
    Console.WriteLine(value * value);
  }
}

Works with: C# version 3.0+

This version uses the C# 3 lambda notation.

int[] intArray = { 1, 2, 3, 4, 5 };
Array.ForEach(intArray, i => Console.WriteLine(i * i));

C++

Works with: g++ version 4.1.1

C-Style Array

#include <iostream> //cout for printing
#include <algorithm> //for_each defined here
 
//create the function (print the square)
void print_square(int i) {
  std::cout << i*i << " ";
}
 
int main() {
  //create the array
  int ary[]={1,2,3,4,5};
  //stl for_each
  std::for_each(ary,ary+5,print_square);
  return 0;
}
//prints 1 4 9 16 25

std::vector

Library: STL

#include <iostream>  // cout for printing
#include <algorithm> // for_each defined here
#include <vector>    // stl vector class
 
// create the function (print the square)
void print_square(int i) {
  std::cout << i*i << " ";
}
 
int main() {
  // create the array
  std::vector<int> ary;
  ary.push_back(1);
  ary.push_back(2);
  ary.push_back(3);
  ary.push_back(4);
  ary.push_back(5);
  // stl for_each
  std::for_each(ary.begin(),ary.end(),print_square);
  return 0;
}
//prints 1 4 9 16 25

More tricky with binary function

#include <iostream>   // cout for printing
#include <algorithm>  // for_each defined here
#include <vector>     // stl vector class
#include <functional> // bind and ptr_fun
 
// create a binary function (print any two arguments together)
template<class type1,class type2>
void print_juxtaposed(type1 x, type2 y) {
  std::cout << x << y;
}
 
int main() {
  // create the array
  std::vector<int> ary;
  ary.push_back(1);
  ary.push_back(2);
  ary.push_back(3);
  ary.push_back(4);
  ary.push_back(5);
  // stl for_each, using binder and adaptable unary function
  std::for_each(ary.begin(),ary.end(),std::bind2nd(std::ptr_fun(print_juxtaposed<int,std::string>),"x "));
  return 0;
}
//prints 1x 2x 3x 4x 5x

Boost.Lambda

Library: Boost

using namespace std;
using namespace boost::lambda;
vector<int> ary(10);
int i = 0;
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

Clean

Define a function and an initial (unboxed) array.

square x = x * x
 
values :: {#Int}
values = {x \\ x <- [1 .. 10]}

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

mapArray f array = {f x \\ x <-: array}

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

Start :: {#Int}
Start = mapArray square values

CoffeeScript

 
map = (arr, f) -> (f(e) for e in arr)
arr = [1, 2, 3, 4, 5]
f = (x) -> x * x
console.log map arr, f # prints [1, 4, 9, 16, 25]
 

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

Clojure

;; apply a named function, inc
(map inc [1 2 3 4])

;; apply a function
(map (fn [x] (* x x)) [1 2 3 4])

;; shortcut syntax for a function
(map #(* % %) [1 2 3 4])

D

import std.stdio, std.algorithm;
 
void main() {
    auto items = [1, 2, 3, 4, 5];
    auto m = items.map!(x => x + 5)();
    writeln(m);
}

Output:

[6, 7, 8, 9, 10]

Delphi

 
// Declare the callback function
procedure callback(const AInt:Integer);
begin
  WriteLn(AInt);
end;
 
const
  // Declare a static array
  myArray:Array[0..4] of Integer=(1,4,6,8,7);
var
  // Declare interator variable
  i:Integer;
begin
  // Iterate the array and apply callback
  for i:=0 to length(myArray)-1 do
    callback(myArray[i]);
end.
 

E

def array := [1,2,3,4,5]
def square(value) { 
    return value * value
}

Example of builtin iteration:

def callback(index, value) { 
    println(`Item $index is $value.`)
}
array.iterate(callback)

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 map(func, collection) {
    def output := [].diverge()
    for item in collection {
        output.push(func(item))
    }
    return output.snapshot()
}
println(map(square, array))

Efene

square = fn (N) {
    N * N
}
 
# list comprehension
squares1 = fn (Numbers) {
    [square(N) for N in Numbers]
}
 
# functional form
squares2a = fn (Numbers) {
    lists.map(fn square:1, Numbers)
}
 
# functional form with lambda
squares2b = fn (Numbers) {
    lists.map(fn (N) { N * N }, Numbers)
}
 
# no need for a function
squares3 = fn (Numbers) {
    [N * N for N in Numbers]
}
 
@public
run = fn () {
    Numbers = [1, 3, 5, 7]
    io.format("squares1 : ~p~n", [squares1(Numbers)])
    io.format("squares2a: ~p~n", [squares2a(Numbers)])
    io.format("squares2b: ~p~n", [squares2b(Numbers)])
    io.format("squares3 : ~p~n", [squares3(Numbers)])
}
 

Elena

#define std'patterns'*.
#define std'routines'*.
#define std'dictionary'*.
 
#symbol PrintSecondPower
    = aNumber => ('program'output << aNumber * aNumber << "%n").
 
#symbol Program =>
[
    // first version
    Scan::(1, 2, 3, 4, 5) run:PrintSecondPower.
 
    // second version
    (ArrayEnumerator::(6, 7, 8, 9, 10))~foreach run: anItem => (PrintSecondPower eval:anItem).
].
 

Erlang

A list would be more commonly used in Erlang rather than an array.

 
1> L = [1,2,3].
[1,2,3]
 

You can use lists:foreach/2 if you just want to apply the callback to each element of the list.

 
2> lists:foreach(fun(X) -> io:format("~w ",[X]) end, L).
1 2 3 ok
 

Or you can use lists:map/2 if you want to create a new list with the result of the callback on each element.

 
3> lists:map(fun(X) -> X + 1 end, L).
[2,3,4]
 

Or you can use lists:foldl/3 if you want to accumulate the result of the callback on each element into one value.

 
4> lists:foldl(fun(X, Sum) -> X + Sum end, 0, L).
6
 

Euphoria

function apply_to_all(sequence s, integer f)
    -- apply a function to all elements of a sequence
    sequence result
    result = {}
    for i = 1 to length(s) do
	-- we can call add1() here although it comes later in the program
	result = append(result, call_func(f, {s[i]}))
    end for
    return result
end function
 
function add1(atom x)
    return x + 1
end function
 
-- add1() is visible here, so we can ask for its routine id
? apply_to_all({1, 2, 3}, routine_id("add1"))
-- displays {2,3,4}

This is also "Example 2" in the Euphoria documentation for routine_id(). Note that this example will not work for multi-dimensional sequences.

Factor

Print each element squared:

{ 1 2 3 4 } [ sq . ] each

Collect return values:

{ 1 2 3 4 } [ sq ] map

Fantom

In Fantom, functions can be passed to a collection iterator, such as 'each'. 'map' is used similarly, and the results are collected into a list.

 
class Main
{
  public static Void main ()
  {
    [1,2,3,4,5].each |Int i| { echo (i) }
    Int[] result := [1,2,3,4,5].map |Int i->Int| { return i * i }
    echo (result) 
  }
}
 

Output:

1
2
3
4
5
[1, 4, 9, 16, 25]

Forth

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

: map ( addr n fn -- )
   -rot cells bounds do  i @ over execute i !  cell +loop ;

Example usage:

create data 1 , 2 , 3 , 4 , 5 ,
data 5 ' 1+ map  \ adds one to each element of data

Fortran

Elemental functions.

Works with: Fortran version ISO 95 and later

module arrCallback
contains
    elemental function cube( x )
        implicit none
        real :: cube
        real, intent(in) :: x
        cube = x * x * x
    end function cube
end module arrCallback

program testAC
    use arrCallback
    implicit none
    integer :: i, j
    real, dimension(3,4) :: b, &
        a = reshape( (/ ((10 * i + j, i = 1, 3), j = 1, 4) /), (/ 3,4 /) )
 
    do i = 1, 3
        write(*,*) a(i,:)
    end do
 
    b = cube( a )  ! Applies CUBE to every member of a,
                   ! and stores each result in the equivalent element of b
    do i = 1, 3
        write(*,*) b(i,:)
    end do
end program testAC

Works with: ANSI FORTRAN version 77 (with MIL-STD-1753 structured DO) and later

      program test
C
C--   Declare array:
      integer a(5)
C
C--   Fill it with Data
      data a /45,22,67,87,98/
C
C--   Do something with all elements (in this case: print their squares)
      do i=1,5
        print *,a(i)*a(i)
      end do
C
      end

FP

{square * . [id, id]}
& square: <1,2,3,4,5>

F#

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

let evenp x = x % 2 = 0
let result = Array.map evenp [| 1; 2; 3; 4; 5; 6 |]

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

let result = Array.map (fun x -> x * x) [|1; 2; 3; 4; 5|]

Use iter if the applied function does not return a value.

Array.iter (fun x -> printfn "%d" x) [|1; 2; 3; 4; 5|]

GAP

a := [1 .. 4];
b := ShallowCopy(a);
 
# Apply and replace values
Apply(a, n -> n*n);
a;
# [ 1, 4, 9, 16 ]
 
# Apply and don't change values
Perform(b, Display);
1
2
3
4
 
b;
# [ 1 .. 4 ]

Go

Translation of: Ruby

The task was originally written with a Ruby example, so here are Go versions of the current Ruby examples.

Perhaps in contrast to Ruby, it is idiomatic in Go to use the for statement:

package main
 
import "fmt"
 
func main() {
    for _, i := range []int{1, 2, 3, 4, 5} {
        fmt.Println(i * i)
    }
}

Alternatively though, an array-like type can be defined and callback-style methods can be defined on it to apply a function to the elements.

package main
 
import "fmt"
 
type intSlice []int
 
func (s intSlice) each(f func(int)) {
    for _, i := range s {
        f(i)
    }
}
 
func (s intSlice) Map(f func(int) int) intSlice {
    r := make(intSlice, len(s))
    for j, i := range s {
        r[j] = f(i)
    }
    return r
}
 
func main() {
    s := intSlice{1, 2, 3, 4, 5}
 
    s.each(func(i int) {
        fmt.Println(i * i)
    })
 
    fmt.Println(s.Map(func(i int) int {
        return i * i
    }))
}

Output:

1
4
9
16
25
[1 4 9 16 25]

Groovy

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 }

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 = mapM_ (print.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

Icon and Unicon

procedure main()
   local lst
   lst := [10, 20, 30, 40]
   every callback(write,!lst)
end
 
procedure callback(p,arg)
   return p(" -> ", arg)
end

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 if a is an n-dimensional array

Io

list(1,2,3,4,5) map(squared)

J

Solution:

   "_1

Example:

   callback =:  *:
   array    =:  1 2 3 4 5
 
   callback"_1 array
1 4 9 16 25

But note that this is a trivial example since *: 1 2 3 4 5 would get the same result. Then again, this is something of a trivial exercise in J since all of J is designed around the idea of applying functions usefully to arrays.

Java

As of the current version of Java, you have to define an interface for each type of function you want to use. The next version of Java will introduce function types.

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);
}
 
for (int z : myIntArray) {
    new IntToVoid() {
        public void run(int x) {
            System.out.println(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);
}
 
int[] result = new int[myIntArray.length];
for (int i = 0; i < myIntArray.length; i++) {
    result[i] =
        new IntToInt() {
            public int run(int x) {
                return x * x;
            }
        }.run(myIntArray[i]);
}

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

Library: BeyondJS

With the 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)];

Library: Functional

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

TIScript

JavaScript alike:

var a = [1, 2, 3, 4, 5];
a.map(function(v) { return v * v; })
 

Using short form of lambda notation:

var a = [1, 2, 3, 4, 5];
a.map( :v: v*v );
 

Joy

[1 2 3 4 5] [dup *] map.

Lisaac

+ a : ARRAY(INTEGER);
+ b : {INTEGER;};
 
a := ARRAY(INTEGER).create 1 to 3;
1.to 3 do { i : INTEGER;
  a.put i to i;
};
 
b := { arg : INTEGER;
  (arg * arg).print;
  '\n'.print;
};
 
a.foreach b;

Logo

to square :x
  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]
foreach [1 2 3 4 5] [print square ?]  ; 1 4 9 16 25, one per line

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 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. However, remember that hash table do not have an implicit ordering on their elements, like arrays do, so pairs() is not guaranteed to return the elements in the same order as ipairs()

M4

define(`foreach', `pushdef(`$1')_foreach($@)popdef(`$1')')dnl
define(`_arg1', `$1')dnl
define(`_foreach', `ifelse(`$2', `()', `',
   `define(`$1', _arg1$2)$3`'$0(`$1', (shift$2), `$3')')')dnl
dnl
define(`apply',`foreach(`x',$1,`$2(x)')')dnl
dnl
define(`z',`eval(`$1*2') ')dnl
apply(`(1,2,3)',`z')

Output:

2 4 6

Mathematica

(#*#)& /@ {1, 2, 3, 4}
 
Map[Function[#*#], {1, 2, 3, 4}]

MATLAB

There are two types of arrays in MATLAB: arrays and cell arrays. MATLAB includes two functions, one for each of these data types, that accomplish the specification for this task. For arrays, we use "arrayfun()"; for cell arrays we use "cellfun()".
Example: For both of these function the first argument is a function handle for the function we would like to apply to each element. The second argument is the array whose elements are modified by the function. The function can be any function, including user defined functions.

>> array = [1 2 3 4 5]
 
array =
 
     1     2     3     4     5
 
>> arrayfun(@sin,array)
 
ans =
 
  Columns 1 through 4
 
   0.841470984807897   0.909297426825682   0.141120008059867  -0.756802495307928
 
  Column 5
 
  -0.958924274663138
 
>> cellarray = {1,2,3,4,5}
 
cellarray = 
 
    [1]    [2]    [3]    [4]    [5]
 
>> cellfun(@tan,cellarray)
 
ans =
 
  Columns 1 through 4
 
   1.557407724654902  -2.185039863261519  -0.142546543074278   1.157821282349578
 
  Column 5
 
  -3.380515006246586

Modula-3

MODULE Callback EXPORTS Main;
 
IMPORT IO, Fmt;
 
TYPE CallBack = PROCEDURE (a: CARDINAL; b: INTEGER);
     Values = REF ARRAY OF INTEGER;
 
VAR sample := ARRAY [1..5] OF INTEGER {5, 4, 3, 2, 1};
    callback := Display;
 
PROCEDURE Display(loc: CARDINAL; val: INTEGER) =
  BEGIN
    IO.Put("array[" & Fmt.Int(loc) & "] = " & Fmt.Int(val * val) & "\n");
  END Display;
 
PROCEDURE Map(VAR values: ARRAY OF INTEGER; size: CARDINAL; worker: CallBack) =
  VAR lvalues := NEW(Values, size);
  BEGIN
    FOR i := FIRST(lvalues^) TO LAST(lvalues^) DO
      worker(i, values[i]);
    END;
  END Map;
 
BEGIN
  Map(sample, NUMBER(sample), callback);
END Callback.

NewLISP

> (map (fn (x) (* x x)) '(1 2 3 4))
(1 4 9 16)
 

Nial

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

Objeck

 
use Structure;
 
bundle Default {
  class Test {
    function : Main(args : String[]) ~ Nil {
      Run();
    }
 
    function : native : Run() ~ Nil {
      values := IntVector->New([1, 2, 3, 4, 5]);
      squares := values->Apply(Square(Int) ~ Int);
      each(i : squares) {
        squares->Get(i)->PrintLine();
      };
    }
 
    function : Square(value : Int) ~ Int {
      return value * value;
    }
  }
}
 

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

Or with lists (which are more typical in OCaml):

let values = [1;2;3;4;5;6;7;8;9;10];;
List.map square values;;

Use iter if the applied function does not return a value.

Array.iter (fun x -> Printf.printf "%d" x) [|1; 2; 3; 4; 5|];;

List.iter (fun x -> Printf.printf "%d" x) [1; 2; 3; 4; 5];;

with partial application we can also write:

Array.iter (Printf.printf "%d") [|1; 2; 3; 4; 5|];;

List.iter (Printf.printf "%d") [1; 2; 3; 4; 5];;

Octave

Almost all the built-in can operate on each element of a vector or matrix; e.g. sin([pi/2, pi, 2*pi]) computes the function sin on pi/2, pi and 2*pi (returning a vector). If a function does not accept vectors/matrices as arguments, the arrayfun can be used.

function e = f(x, y)
  e = x^2 + exp(-1/(y+1));
endfunction
 
% f([2,3], [1,4]) gives and error, but
arrayfun(@f, [2, 3], [1,4])
% works

(The function f can be rewritten so that it can accept vectors as argument simply changing operators to their dot relatives: e = x.^2 + exp(-1 ./ (y.+1)))

Oz

declare
  fun{Square A}
    A*A
  end
 
  Lst = [1 2 3 4 5]
 
  %% apply a PROCEDURE to every element
  {ForAll Lst Show}
 
  %% apply a FUNCTION to every element
  Result = {Map Lst Square}
  {Show Result}

PARI/GP

Works with: PARI/GP version 2.4.3 and above

This code uses the select() function, which was added in PARI version 2.4.2. The order of the arguments changed between versions; to use in 2.4.2 change select(function, vector) to select(vector, function).

callback(n)=n+n;
apply(callback, [1,2,3,4,5])

Pascal

See Delphi

Perl

# create array
my @a = (1, 2, 3, 4, 5);
 
# create callback function
sub mycallback {
  return 2 * shift;
}
 
# use array indexing
for (my $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)
 
# filter an array 
my @e = grep { $_ % 2 == 0 } @a;               # @e is now (2, 4)

Perl 6

Works with: Rakudo version #21 "Seattle"

my $function = { 2 * $^x + 3 };
my @array = 1 .. 5;
 
# via map function
.say for map $function, @array;
 
# via map method
.say for @array.map($function);
 
# via for loop
for @array {
    say $function($_);
}
 
# via the "hyper" metaoperator and method indirection
say @array».$function;

PHP

function cube($n)
{
   return($n * $n * $n);
}
 
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);

PicoLisp

: (mapc println (1 2 3 4 5))  # Print numbers
1
2
3
4
5
-> 5
 
: (mapcar '((N) (* N N)) (1 2 3 4 5))  # Calculate squares
-> (1 4 9 16 25)
 
: (mapcar ** (1 2 3 4 5) (2 .))  # Same, using a circular list
-> (1 4 9 16 25)
 
: (mapcar if '(T NIL T NIL) '(1 2 3 4) '(5 6 7 8))  # Conditional function
-> (1 6 3 8)

Pike

int cube(int n)
{
    return n*n*n;
}
 
array(int) a = ({ 1,2,3,4,5 });
array(int) b = cube(a[*]);      // automap operator
array(int) c = map(a, cube);    // conventional map function

PL/SQL

Works with: Oracle

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 := x.FIRST;
      -- square array
      WHILE i IS NOT NULL LOOP
              x(i) := x(i)*x(i);
              DBMS_OUTPUT.put_line(x(i));
              i := x.next(i);
      END LOOP;
END;
/

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.

PostScript

The forall operator applies a procedure to each element of an array, a packed array or a string.

[1 2 3 4 5] { dup mul = } forall

In this case the respective square numbers for the elements are printed.

To create a new array from the results above code can simply be wrapped in []:

[ [1 2 3 4 5] { dup mul } forall ]

Library: initlib

 
[1 2 3 4 5] {dup *} map
 

PowerShell

This can be done in PowerShell with the ForEach-Object cmdlet which applies a scriptblock to each element of an array:

1..5 | ForEach-Object { $_ * $_ }

To recreate a map function, found in other languages the same method applies:

function map ([array] $a, [scriptblock] $s) {
    $a | ForEach-Object $s
}

Prolog

Prolog doesn't have arrays, but we can do it with lists. This can be done in the console mode.

 ?- assert((fun(X, Y) :- Y is 2 * X)).
true.
 
?- maplist(fun, [1,2,3,4,5], L).
L = [2,4,6,8,10].
 

PureBasic

Procedure Cube(Array param.i(1))
    Protected n.i
    For n = 0 To ArraySize(param())
        Debug Str(param(n)) + "^3 = " + Str(param(n) * param(n) * param(n))
    Next 
EndProcedure 
 
Dim AnArray.i(4)
 
For n = 0 To ArraySize(AnArray()) 
    AnArray(n) = Random(99)
Next 
 
Cube(AnArray()) 

Python

def square(n):
    return n * n
 
numbers = [1, 3, 5, 7]
 
squares1 = [square(n) for n in numbers]     # list comprehension
 
squares2a = map(square, numbers)            # functional form
 
squares2b = map(lambda x: x*x, numbers)     # functional form with `lambda`
 
squares3 = [n * n for n in numbers]         # no need for a function,
                                            # anonymous or otherwise
 
isquares1 = (n * n for n in numbers)        # iterator, lazy
 
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

R

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

cube <- function(x) x*x*x
elements <- 1:5
cubes <- cube(elements)

Explicit looping over array elements is also possible.

cubes <- numeric(5)
for(i in seq_along(cubes))
{
   cubes[i] <- cube(elements[i])
}

Loop syntax can often simplified using the *apply family of functions.

elements2 <- list(1,2,3,4,5)
cubes <- sapply(elements2, cube)

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

1   8  27  64 125

Raven

# To print the squared elements
[1 2 3 4 5] each dup * print

# To obtain a new array
group [1 2 3 4 5] each
  dup *
list

REBOL

rebol [
    Title: "Array Callback"
    Date: 2010-01-04
    Author: oofoe
    URL: http://rosettacode.org/wiki/Apply_a_callback_to_an_Array
]
 
map: func [
	"Apply a function across an array."
	f [native! function!] "Function to apply to each element of array."
	a [block!] "Array to process."
	/local x
][x: copy []  forall a [append x do [f a/1]]  x]
 
square: func [x][x * x]
 
; Tests:
 
assert: func [code][print [either do code ["  ok"]["FAIL"]  mold code]]
 
print "Simple loop, modify in place:"
assert [[1 100 81] = (a: [1 10 9]  forall a [a/1: square a/1]  a)]
 
print [crlf "Functional style with 'map':"]
assert [[4 16 36] = map :square [2 4 6]]
 
print [crlf "Applying native function with 'map':"]
assert [[2 4 6] = map :square-root [4 16 36]]

Output:

Simple loop, modify in place:
  ok [[1 100 81] = (a: [1 100 81] forall a [a/1: square a/1] a)]

Functional style with 'map':
  ok [[4 16 36] = map :square [2 4 6]]

Applying native function with 'map':
  ok [[2 4 6] = map :square-root [4 16 36]]

Retro

Using the array' library to multiply each value in an array by 10 and display the results:

[ 1 2 3 4 5 ] ^array'fromQuote [ 10 * ] ^array'map ^array'display

Retro also provides ^array'apply for use when you don't want to alter the contents of the array:

[ "Hello" "World" "Foo" ] ^array'fromQuote [ "%s " puts ] ^array'apply

REXX

/*REXX program to apply a callback to an array.  */
        a.=;   b.=
 a.0= 0
 a.1= 1
 a.2= 2
 a.3= 3
 a.4= 4
 a.5= 5
 a.6= 6
 a.7= 7
 a.8= 8
 a.9= 9
a.10=10
 
call listab 'before'
call bangit 'a','b'      /*factorialize the A array, store results in B */
call listab ' after'
exit
/*─────────────────────────────────────BANGIT subroutine────────────────*/
bangit:   do j=0
          _=value(arg(1)'.'j); if _=='' then return
          call value arg(2)'.'j,fact(_)
          end
/*─────────────────────────────────────FACT subroutine──────────────────*/
fact: procedure; !=1; do j=2 to arg(1); !=!*j; end; return !
 
/*─────────────────────────────────────LISTAB subroutine────────────────*/
listab: do j=0 while a.j\==''
        say arg(1) 'a.'j"="a.j
        end
say
        do j=0 while b.j\==''
        say arg(1) 'b.'j"="b.j
        end
return

output

before a.0=0
before a.1=1
before a.2=2
before a.3=3
before a.4=4
before a.5=5
before a.6=6
before a.7=7
before a.8=8
before a.9=9
before a.10=10

 after a.0=0
 after a.1=1
 after a.2=2
 after a.3=3
 after a.4=4
 after a.5=5
 after a.6=6
 after a.7=7
 after a.8=8
 after a.9=9
 after a.10=10

 after b.0=1
 after b.1=1
 after b.2=2
 after b.3=6
 after b.4=24
 after b.5=120
 after b.6=720
 after b.7=5040
 after b.8=40320
 after b.9=362880
 after b.10=3628800

RLaB

RLaB has two type of arrays: 'standard' or 1-dimensional, that can be a row- or a column-vectory; and, 'associative' which are called lists. For standard array its entry identifier (index) is an integer in range 1:N where N is the size of the array. For associative array its entry identifier is a string consisting of printable ASCII characters.

All scalar mathematical functions are 'matrix-optimized' meaning that if the argument to a function is a matrix, then the return value of the function is a matrix of the same size as the input argument, where the function is applied to the individual entries of the matrix. Consider an example:

 
>> x = rand(2,4)
 0.707213207   0.275298961   0.396757763   0.232312312
 0.215619868   0.207078017   0.565700032   0.666090571
>> sin(x)
 0.649717845   0.271834652   0.386430003   0.230228332
 0.213952984   0.205601224   0.536006923   0.617916954
 

This can be done on entry-by-entry basis, but one has to keep in mind that the 'for' or 'while' loops are slow in interpreted languages, and RLaB is no exception.

 
x = rand(2,4);
y = zeros(2,4);
for (i in 1:2)
{
  for (j in 1:4)
  {
    y[i;j] = sin( x[i;j] );
  }
}
 

The functions can take lists as arguments, but then it has to be specified within the body of the function what to do with the list elements. Given a list call it 'x' there is a RLaB function 'members' which returns a string vector with the names of the elements of the list.

 
x = <<>>;
for (i in 1:9)
{
  x.[i] = rand();
}
 
y = <<>>;
for (i in members(x))
{
  y.[i] = sin( x.[i] );
}
 

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 }

Salmon

These examples apply the square function to a list of the numbers from 0 through 9 to produce a new list of their squares, then iterate over the resulting list and print the squares.

function apply(list, ageless to_apply)
  (comprehend(x; list) (to_apply(x)));
 
function square(x) (x*x);
 
iterate(x; apply([0...9], square))
    x!;

With short identifiers:

include "short.salm";
 
fun apply(list, ageless to_apply)
  (comp(x; list) (to_apply(x)));
 
fun square(x) (x*x);
 
iter(x; apply([0...9], square))
    x!;

With the numbers given as a list of individual elements:

function apply(list, to_apply)
  (comprehend(x; list) (to_apply(x)));
 
function square(x) (x*x);
 
iterate(x; apply([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], square))
    x!;

Sather

class MAIN is
  do_something(i:INT):INT is
    return i * i;
  end;
 
  main is
    a:ARRAY{INT} := |1, 2, 3, 4, 5|;
    -- we use an anonymous closure to apply our do_something "callback"
    a.map(bind(do_something(_)));
    loop #OUT + a.elt! + "\n"; end;
  end;
end;

Scala

val l = List(1,2,3,4)
l.foreach {i => println(i)}

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

l.foreach(println(_))

Same for an array

val a = Array(1,2,3,4)
a.foreach {i => println(i)}
a.foreach(println(_))  '' // same as previous line''

Or for an externally defined function:

def doSomething(in: int) = {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 defined on a

for(val i <- a) 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} ''//squares is''  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

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

Slate

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

Smalltalk

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

Standard ML

 
map f l
 

i.e.

 
map (fn x=>x+1) [1,2,3];; (* [2,3,4] *)
 

SuperCollider

Actually, there is a builtin squared operator:

[1, 2, 3].squared;  // returns [1, 4, 9]

Anything that is a Collection can be used with collect:

[1, 2, 3].collect({ arg x; x*x });

List comprehension combined with a higher-order function can also be used:

var square = {
  arg x;
  x*x;
};
var map = {
  arg fn, xs;
  all {: fn.value(x), x <- xs };
};
map.value(square,[1,2,3]);

Tcl

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

foreach var $dat {
    myfunc $var
}

This does not retain any of the values returned by myfunc.

if dat were an (associative) array, however:

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

More functional, with a simple map function:

proc map {f list} {
   set res {}
   foreach e $list {lappend res [$f $e]}
   return $res
}
proc square x {expr {$x*$x}}
 
% map square {1 2 3 4 5}
1 4 9 16 25

TI-89 BASIC

© For no return value
Define foreach(fe_cname,fe_list) = Prgm
  Local fe_i
  For fe_i,1,dim(fe_list)
    #fe_cname(fe_list[fe_i])
  EndFor
EndPrgm
 
© For a list of results
Define map(map_cnam,map_list) = seq(#map_cnam(map_list[map_i]),map_i,1,dim(map_list))
 
Define callback(elem) = Prgm
  Disp elem
EndPrgm
 
foreach("callback", {1,2,3,4,5})
Disp map("√", {1,2,3,4,5})

Output:

1
2
3
4
5
$\begin{Bmatrix}1 & \sqrt{2} & \sqrt{3} & 2 & \sqrt{5}\end{Bmatrix}$

Toka

( array count function -- )
{
  value| array fn |
  [ i array ] is I
  [ to fn swap to array 0 swap [ I array.get :stack fn invoke I array.put ] countedLoop ]
} is map-array
 
( Build an array )
5 cells is-array a
10 0 a array.put
11 1 a array.put
12 2 a array.put
13 3 a array.put
14 4 a array.put
 
( Add 1 to each item in the array )
a 5  [ 1 + ] map-array

TXR

Print 1 through 10:

@(do
   (defun mapvec (vec fun)
     (each ((i (range 0 (- (length vec) 1))))
       [fun [vec i]]))
 
   (mapvec #(1 2 3 4 5 6 7 8 9 10)
           (lambda (x) (format t "~a\n" x))))

UNIX Shell

Works with: Bourne Shell

map() {
	map_command=$1
	shift
	for i do "$map_command" "$i"; done
}
list=1:2:3
(IFS=:; map echo $list)

Works with: ksh93

Works with: pdksh

Works with: zsh

map() {
	typeset command=$1
	shift
	for i do "$command" "$i"; done
}
set -A ary 1 2 3
map print "${ary[@]}"

Works with: zsh

map(){for i ($*[2,-1]) $1 $i}
a=(1 2 3)
map print $a

Ursala

The * is a built-in map operator. This example shows a map of the successor function over a list of natural numbers.

#import nat
 
#cast %nL
 
demo = successor* <325,32,67,1,3,7,315>

output:

<326,33,68,2,4,8,316>

V

apply squaring (dup *) to each member of collection

[1 2 3 4] [dup *] map

VBScript

I really have my doubts as to whether this really counts as a callback. I used the same thing in the solution to Amb.

Implementation

 
class callback
	dim sRule
 
	public property let rule( x )
		sRule = x
	end property
 
	public default function applyTo(a)
		dim p1
		for i = lbound( a ) to ubound( a )
			p1 = a( i )
			a( i ) = eval( sRule )
		next
		applyTo = a
	end function
end class
 

Invocation

 
dim a1
dim cb
set cb = new callback
 
cb.rule = "ucase(p1)"
a1 = split("my dog has fleas", " " )
cb.applyTo a1
wscript.echo join( a1, " " )
 
cb.rule = "p1 ^ p1"
a1 = array(1,2,3,4,5,6,7,8,9,10)
cb.applyto a1
wscript.echo join( a1, ", " )
 
 

Output

MY DOG HAS FLEAS
1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489, 10000000000

Vorpal

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

A.map(F)

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.

A.map(F, x, y)