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.

ActionScript

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

} </lang>

Ada

Works with: GNAT version GPL 2005

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

</lang>

ALGOL 68

 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

C

Works with: gcc version 4.1.1

Works with: TCC version 0.9.23

Works with: ICC version 9.1

callback.h

<lang c>

1. ifndef CALLBACK_H
2. 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));

1. endif

</lang>

callback.c

<lang c>

1. include <stdio.h>
2. 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;

} </lang>

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

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

} </lang>

Works with: C# version 3.0+

This version uses the C# 3 lambda notation.

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

C++

Works with: g++ version 4.1.1

C-Style Array

<lang cpp>

1. include <iostream> //cout for printing
2. 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 </lang>

std::vector

Library: STL

<lang cpp>

1. include <iostream> // cout for printing
2. include <algorithm> // for_each defined here
3. 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 </lang>

More tricky with binary function <lang>

1. include <iostream> // cout for printing
2. include <algorithm> // for_each defined here
3. include <vector> // stl vector class
4. 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 </lang>

Boost.Lambda

Library: Boost

<lang cpp> 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 </lang>

Clean

Define a function and an initial (unboxed) array.

<lang clean> square x = x * x

values :: {#Int} values = {x \\ x <- [1 .. 10]} </lang>

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

<lang clean> mapArray f array = {f x \\ x <-: array} </lang>

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

<lang clean> Start :: {#Int} Start = mapArray square values </lang>

Common Lisp

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

<lang lisp> (map nil #'print #(1 2 3 4 5)) </lang>

Functional: collect squares into new vector that is returned:

<lang lisp> (defun square (x) (* x x)) (map 'vector #'square #(1 2 3 4 5)) </lang>

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

<lang lisp> (defvar *a* (vector 1 2 3)) (map-into *a* #'1+ *a*) </lang>

Clojure

<lang clojure>

apply a named function, inc

(map inc [1 2 3 4]) </lang>

<lang clojure>

apply a function

(map (fn [x] (* x x)) [1 2 3 4]) </lang>

<lang clojure>

shortcut syntax for a function

(map #(* % %) [1 2 3 4]) </lang>

D

<lang d> U[] map(T, U)(T[] array, U delegate(T) dg) {

   auto result = new U[array.length];

   foreach (index, element; array)
       result[index] = dg(element);

   return result;

}

void main() {

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

} </lang> Using std.algorithm: <lang d> writefln(map!("a + 5")([1, 2, 3, 4, 5])); </lang>

E

<lang e> def array := [1,2,3,4,5] def square(value) {

   return value * value

} </lang>

Example of builtin iteration:

<lang e> def callback(index, value) {

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

} array.iterate(callback) </lang>

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

<lang e> def map(func, collection) {

   def output := [].diverge()
   for item in collection {
       output.push(func(item))
   }
   return output.snapshot()

} println(map(square, array)) </lang>

Forth

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

<lang forth>

map ( addr n fn -- )

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

</lang>

Example usage:

<lang forth> create data 1 , 2 , 3 , 4 , 5 , data 5 ' 1+ map \ adds one to each element of data </lang>

Fortran

Elemental functions.

Works with: Fortran version ISO 95 and later

<lang fortran> 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 </lang>

<lang fortran> 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 </lang>

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

<lang fortran>

     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

</lang>

FP

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

Groovy

Print each value in a list <lang groovy>

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

</lang>

Create a new list containing the squares of another list <lang groovy>

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

</lang>

Haskell

List

Works with: GHC

<lang haskell> let square x = x*x let values = [1..10] map square values </lang>

Using list comprehension to generate a list of the squared values <lang haskell> [square x | x <- values] </lang>

Using function composition to create a function that will print the squares of a list <lang haskell> let printSquares = putStr.unlines.map (show.square) printSquares values </lang>

Array

Works with: GHC

<lang haskell> 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 </lang>

Icon

<lang icon> procedure main()

  local lst
  lst := [10, 20, 30, 40]
  every callback(!lst)

end

procedure callback(arg)

  write("->", arg)

end </lang>

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

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:

<lang java> interface IntToVoid {

   void run(int x);

}

for (int z : myIntArray) {

   new IntToVoid() {
       public void run(int x) {
           System.out.println(x);
       }
   }.run(z);

} </lang>

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

<lang java> 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]);

} </lang>

JavaScript

Portable technique:

<lang javascript> 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; }); </lang>

Library: BeyondJS

With the BeyondJS library:

<lang javascript> var a = (1).to(10).collect(Math.pow.curry(undefined,2)); </lang>

With Firefox 2.0:

<lang javascript> 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)]; </lang>

Library: Functional

<lang javascript> Functional.map('x*x*x', [1,2,3,4,5]) </lang>

Logo

<lang 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 </lang>

Lua

Say we have an array: <lang lua> myArray = {1, 2, 3, 4, 5} </lang> A map function for this would be <lang lua> map = function(f, data)

  local result = {}
  for k,v in ipairs(data) do
     result[k] = f(v)
  end
  return result

end </lang> Together with our array and and a square function this yields: <lang lua> myFunc = function(x) return x*x end

print(unpack( map(myFunc, myArray) )) --> 1 4 9 16 25 </lang> If you used pairs() instead of ipairs(), this would even work on a hash table in general.

Nial

<lang nial>

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

</lang>

OCaml

This function is part of the standard library:

<lang ocaml> Array.map </lang>

Usage example: <lang ocaml> let square x = x * x;; let values = Array.init 10 ((+) 1);; Array.map square values;; </lang>

Oz

<lang oz> functor import

 Application System

define

 Print = System.showInfo

 fun{Square A}
   A*A
 end

 fun{FuncEach Func A}
   {Map A Func}
 end

 proc{ProcEach Proc A}
   {ForAll A Proc}
 end

 Arr = [1 2 3 4 5]

 {ProcEach Print {FuncEach Square Arr}}

 {ForAll {Map Arr Square} Print}           %% same

 {Application.exit 0}

end </lang>

Perl

<lang perl>

1. create array

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

1. create callback function

sub mycallback {

 return 2 * shift;

}

1. use array indexing

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

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

}

1. using foreach

foreach my $x (@a) {

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

}

1. using map (useful for transforming an array)

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

1. and the same using an anonymous function

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

1. use a callback stored in a variable

my $func = \&mycallback; my @d = map $func->($_), @a; # @d is now (2, 4, 6, 8, 10) </lang>

PHP

<lang php> function cube($n) {

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

}

$a = array(1, 2, 3, 4, 5); $b = array_map("cube", $a); print_r($b); </lang>

PL/SQL

Works with: Oracle

<lang plsql> 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; / </lang>

Pop11

<lang 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); </lang>

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

Python

<lang 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 </lang> To print squares of integers in the range from 0 to 9, type: <lang python> print " ".join(str(n * n) for n in range(10)) </lang> Or: <lang python> print " ".join(map(str, map(square, range(10)))) </lang> Result: <lang python> 0 1 4 9 16 25 36 49 64 81 </lang>

Raven

<lang raven>

1. To print the squared elements

[1 2 3 4 5] each dup * print </lang>

<lang raven>

1. To obtain a new array

group [1 2 3 4 5] each

 dup *

list </lang>

Ruby

You could use a traditional "for i in arr" approach like below: <lang ruby> for i in [1,2,3,4,5] do

  puts i**2

end </lang>

Or you could the more preferred ruby way of an iterator (which is borrowed from SmallTalk) <lang ruby> [1,2,3,4,5].each{ |i| puts i**2 } </lang>

To create a new array of each value squared <lang ruby> [1,2,3,4,5].map{ |i| i**2 } </lang>

Scala

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

When the argument appears only once -as here, i appears only one in println(i) - it may be shortened to <lang scala> l.foreach(println(_)) </lang> Same for an array <lang scala> val a = Array(1,2,3,4) a.foreach {i => println(i)} a.foreach(println(_)) // same as previous line </lang>

Or for an externally defined function: <lang scala> def doSomething(in: int) = {println("Doing something with "+in)} l.foreach(doSomething) </lang>

There is also a for syntax, which is internally rewritten to call foreach. A foreach method must be defined on a <lang scala> for(val i <- a) println(i) </lang>

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) <lang scala> val squares = l.map{i => i * i} //squares is List(1,4,9,16) </lang>

Or the equivalent for syntax, with the additional keyword yield, map is called instead of foreach <lang scala> val squares = for (val i <- l) yield i * i </lang>

Scheme

<lang scheme> (define (square n) (* n n)) (define x #(1 2 3 4 5)) (map square (vector->list x)) </lang>

A single-line variation <lang scheme> (map (lambda (n) (* n n)) '(1 2 3 4 5)) </lang>

For completeness, the map function (which is R5RS standard) can be coded as follows: <lang scheme> (define (map f L)

 (if (null? L)
     L
     (cons (f (car L)) (map f (cdr L)))))

</lang>

Smalltalk

<lang smalltalk>

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

</lang>

Tcl

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

<lang tcl> foreach var $dat { myfunc $var } </lang>

if dat were an array, however:

<lang tcl> foreach name [array names dat] { myfunc $dat($name) } </lang>

Toka

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

</lang>

V

apply squaring (dup *) to each member of collection <lang v>

[1 2 3 4] [dup *] map

</lang>