Apply a callback to an array: Difference between revisions

=={{header|11l}}==

{{trans|Kotlin}}

V arrsq = array.map(i -> i * i)

{{out}}

<pre>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]</pre>

For this example, assume both the source array and the destination have a size of 86 elements (memory offsets base+0x00 to base+0x55.)

This was implemented in easy6502.

define SRC_HI $01

 

CLC

ADC temp ;2a + a = 3a

 

 

{{trans|11l}}

The following assumes all code/data is stored/executed in RAM and is therefore mutable.

MOVE.W #(MyArray_End-MyArray)-1,D7 ;Len(MyArray)-1

MOVEQ #0,D0 ;sanitize D0-D2 to ensure nothing from any previous work will affect our math.

MyArray:

DC.B 1,2,3,4,5,6,7,8,9,10

 

 

=={{header|8th}}==

The builtin word "a:map" does this:

[ 1 , 2, 3 ]

' n:sqr

a:map

That results in the array [1,4,9]

 

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

 

(if (endp xs)

nil

(defun fn-to-apply (x)

(* x x))

 

=={{header|ActionScript}}==

{

public class ArrayCallback

}

}

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2005}}

with Ada.Integer_text_IO;

begin

Map(Sample, Display'access);

 

=={{header|Aime}}==

map(list l, void (*fp)(object))

{

 

return 0;

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

(

printf(($"array["g"] = "gl$, location, value))

[4]INT array := ( 1, 4, 9, 16 );

map(array, call back proc)

 

{{Out}}

 

=={{header|ALGOL W}}==

procedure printSquare ( integer value x ) ; writeon( i_w := 1, s_w := 0, " ", x * x );

% applys f to each element of a from lb to ub (inclusive) %

applyI( printSquare, a, 1, 3 )

end

 

=={{header|APL}}==

By default functions in APL work on arrays as it is an array oriented language. Some examples:

 

¯1 ¯2 ¯3

2 * 1 2 3 4

81 243 729

2187 6561 19683

 

=={{header|AppleScript}}==

-- Returns a string like "arc has 3 letters"

arg & " has " & (count arg) & " letters"

-- to callback, then speaks the return value.

say (callback for aref)

 

If the callback would <code>set arg's contents to "something"</code>, then <code>alist</code> would be mutated.

For a more general implementation of '''map(function, list)''', '''foldl(function, startValue, list)''', and '''filter(predicate, list)''', we could write:

 

set xs to {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

return lst

end tell

{{Out}}

<pre>{{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}, {2, 4, 6, 8, 10}, 55}</pre>

 

=={{header|Arturo}}==

 

{{out}}

 

=={{header|AutoHotkey}}==

 

callback(array){

map(callback, array){

%callback%(array)

 

=={{header|AWK}}==

4 16

5 25

1 1

2 4

 

=={{header|Babel}}==

Let us define a squaring operator:

 

 

Now, we apply the sq operator over a list and display the result using the lsnum utility:

 

 

{{Out}}

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

a() = 1, 2, 3, 4, 5

PROCmap(a(), FNsqrt())

NEXT

ENDPROC

{{Out}}

<pre>

 

=={{header|Bracmat}}==

= location value

. !arg:(?location,?value)

& mapar$(array,4,callbackFunction2)

& mapar$(array,4,callbackFunction1)

{{Out}}

<pre>array[0] = 1

=={{header|Brat}}==

 

[:a :b :c :d :e].each { element |

p element

 

Alternatively:

 

 

=={{header|C}}==

 

'''callback.h'''

#define CALLBACK_H

 

void map(int* array, int len, void(*callback)(int,int));

 

 

'''callback.c'''

#include "callback.h"

 

map(array, 4, callbackFunction);

return 0;

 

{{Out}}

This version uses the C# 3 lambda notation.

 

// Simplest method: LINQ, functional

int[] squares1 = intArray.Select(x => x * x).ToArray();

// Or, if you only want to call a function on each element, just use foreach

foreach (var i in intArray)

 

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

 

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

 

static class Program

Console.WriteLine(value * value);

}

 

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

 

===C++11===

#include <iostream>

#include <algorithm>

std::cout << std::endl;

return 0;

 

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

'''Math operations'''

'''Quick functions'''

'''Anonymous function'''

-> * fn n:

n * 2 + 1

'''Named function'''

n * 2 + 1

 

 

=={{header|Clojure}}==

 

 

 

 

=={{header|CLU}}==

% of the given array. Thanks to CLU's type parameterization,

% it will work for any type of element.

stream$putl(po, "\nStrings: ")

apply_to_all[string](strings, show_string)

{{out}}

<pre>Ints:

 

Basic implementation of a map function:

PROGRAM-ID. Map.

 

 

GOBACK

 

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

 

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

BlackBox Component Builder

MODULE Callback;

IMPORT StdLog;

END Do;

END Callback.

Execute: ^Q Callback.Do<br/>

{{Out}}

=={{header|Crystal}}==

Calling with a block

 

new_values = values.map do |number|

end

 

 

Calling with a function/method

 

def double(number)

new_values = values.map &->double(Int32)

 

 

=={{header|D}}==

 

void main() {

auto m = items.map!(x => x + 5)();

writeln(m);

{{out}}

<pre>[6, 7, 8, 9, 10]</pre>

 

=={{header|Delphi}}==

// Declare the callback function

procedure callback(const AInt:Integer);

callback(myArray[i]);

end.

 

=={{header|Dyalect}}==

 

let ys = []

for x in this when pred(x) {

var squares = arr.Select(x => x * x)

 

=={{header|Déjà Vu}}==

There is a <code>map</code> builtin that does just this.

 

#implemented roughly like this:

# for i in lst:

# f i

{{out}}

<pre>[ 2 5 9 ]</pre>

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

returning a plain list (which is usually an array in implementation).

 

def output := [].diverge()

for item in collection {

return output.snapshot()

}

 

=={{header|EchoLisp}}==

(vector-map sqrt #(0 4 16 49))

→ #( 0 2 4 7)

v[2] = 4

→ #( 4 9 16)

 

=={{header|Efene}}==

 

N * N

}

io.format("squares3 : ~p~n", [squares3(Numbers)])

}

 

=={{header|EGL}}==

 

program ApplyCallbackToArray

return( i * i );

end

 

=={{header|Elena}}==

ELENA 5.0 :

 

PrintSecondPower(n){ console.writeLine(n * n) }

{

new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.forEach:PrintSecondPower

 

=={{header|Elixir}}==

Enum.map([1, 2, 3], fn(n) -> n * 2 end)

Enum.map [1, 2, 3], &(&1 * 2)

 

{{Out}}

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

 

=={{header|ERRE}}==

PRINT

END PROGRAM

This example shows how to pass a function to a procedure.

{{Out}}

 

=={{header|Euphoria}}==

-- apply a function to all elements of a sequence

sequence result

-- add1() is visible here, so we can ask for its routine id

? apply_to_all({1, 2, 3}, routine_id("add1"))

This is also "Example 2" in the Euphoria documentation for <code>routine_id()</code>.

Note that this example will not work for multi-dimensional sequences.

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

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

 

=={{header|Factor}}==

Print each element squared:

 

Collect return values:

 

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

{

}

}

 

{{Out}}

=={{header|FBSL}}==

'''User-defined mapping function:'''

 

FOREACH DIM e IN MyMap(Add42, {1, 2, 3})

END FUNCTION

 

{{Out}}

<pre>43 44 45

 

'''Standard MAP() function:'''

 

DIM languages[] = {{"English", {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"}}, _

MAP(NameANumber, lang[0], 1 TO 10, lang[1])

PRINT LPAD("", 40, "-")

{{Out}}

<pre>The number 1 is called "one" in English

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

 

 

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

 

Sub PrintEx(n As Integer)

Print

Print "Press any key to quit the program"

 

{{out}}

 

=={{header|Frink}}==

f = {|x| x^2} // Anonymous function to square input

a = [1,2,3,5,7]

println[map[f, a]]

 

=={{header|FunL}}==

 

 

{{out}}

 

=={{header|Futhark}}==

map f l

e.g.

map (\x->x+1) [1,2,3] -- [2,3,4]

or equivalently

map (+1) [1,2,3] -- [2,3,4]

 

=={{header|Fōrmulæ}}==

 

=={{header|GAP}}==

b := ShallowCopy(a);

 

 

b;

 

=={{header|Go}}==

 

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

 

import "fmt"

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.

 

import "fmt"

return i * i

}))

{{out}}

<pre>

 

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

 

More directly

 

Or with one less layer of monadic wrapping

 

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

 

===Array===

{{works with|GHC|7.10.3}}

 

square :: Int -> Int

 

main :: IO ()

{{Out}}

<pre>array (1,10) [(1,1),(2,4),(3,9),(4,16),(5,25),(6,36),(7,49),(8,64),(9,81),(10,100)]</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

local lst

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

procedure callback(p,arg)

return p(" -> ", 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}}==

 

'''Solution''':

 

'''Example''':

array =: 1 2 3 4 5

callback"_1 array

 

But note that this is a trivial example since <code>*: 1 2 3 4 5</code> 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.

while the <code>IntToInt</code> is used to replace the array values.

 

 

interface IntConsumer {

});

}

 

Using Java 8 streams:

{{works with|Java|8}}

 

 

public class ArrayCallback {

System.out.println("sum: " + sum);

}

 

=={{header|JavaScript}}==

 

===ES3===

var ret = [];

for (var i = 0; i < a.length; i++) {

}

 

 

===ES5===

 

===ES6===

 

The result is always:

 

=={{header|Joy}}==

 

=={{header|jq}}==

map(exp) # exponentiate each item in the input list

 

# Elementwise operation

[.[] + 1 ] # add 1 to each element of the input array

[0, 1 , 10]

 

=={{header|Jsish}}==

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

 

[1, 2, 3, 4, 5].map(function(v,i,a) { return v * v; }) ==> [ 1, 4, 9, 16, 25 ]

=!EXPECTEND!=

 

{{out}}

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

@show [n ^ 2 for n in numbers] # list comprehension

@show [n * n for n in numbers] # no need for a function,

@show numbers .* numbers # element-wise operation

 

=={{header|Kotlin}}==

val array = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) // build

val function = { i: Int -> i * i } // function to apply

val list = array.map { function(it) } // process each item

println(list) // print results

{{out}}

<pre>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]</pre>

 

=={{header|Klingphix}}==

 

( 1 2 3 4 ) [dup *] map

pstack

 

{{out}}

<pre>((1, 4, 9, 16))</pre>

 

=={{header|Lambdatalk}}==

{A.map {lambda {:x} {* :x :x}} {A.new 1 2 3 4 5 6 7 8 9 10}}

-> [1,4,9,16,25,36,49,64,81,100]

 

=={{header|Lang5}}==

[1 2 3 4 5] square . "\n" .

 

=={{header|langur}}==

 

{{out}}

 

=={{header|Lasso}}==

 

local(

}

 

-> array(1, 8, 27, 64, 125)

 

=={{header|Lisaac}}==

+ b : {INTEGER;};

 

};

 

 

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

However, remember that hash table do not have an implicit ordering on their elements, like arrays do,

 

=={{header|M2000 Interpreter}}==

a=(1,2,3,4,5)

b=lambda->{

Print s=>sum=115

 

 

=={{header|M4}}==

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

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

dnl

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

 

{{Out}}

For lists and sets, which in Maple are immutable, a new object is returned.

Either the built-in procedure map, or the short syntax of a trailing tilde (~) on the applied operator may be used.

> map( sqrt, [ 1.1, 3.2, 5.7 ] );

[1.048808848, 1.788854382, 2.387467277]

> (x -> x + 1)~( { 1, 3, 5 } );

{2, 4, 6}

For Arrays (Vectors, Matrices, etc.) both map and trailing tilde also work, and by default create a new object, leaving the input Array unchanged.

> a := Array( [ 1.1, 3.2, 5.7 ] );

a := [1.1, 3.2, 5.7]

> a;

[1.1, 3.2, 5.7]

However, since these are mutable data structures in Maple, it is possible to use map to modify its input according to the applied procedure.

> map[inplace]( sqrt, a );

[1.048808848, 1.788854382, 2.387467277]

> a;

[1.048808848, 1.788854382, 2.387467277]

The Array a has been modified.

 

It is also possible to pass additional arguments to the mapped procedure.

> map( `+`, [ 1, 2, 3 ], 3 );

[4, 5, 6]

Passing additional arguments *before* the arguments from the mapped data structure is achieved using map2, or the more general map[n] procedure.

> map2( `-`, 5, [ 1, 2, 3 ] );

[4, 3, 2]

> map[2]( `/`, 5, [ 1, 2, 3 ] );

[5, 5/2, 5/3]

 

=={{header|Mathematica}}//{{header|Wolfram Language}}==

Map[Function[#*#], {1, 2, 3, 4}]

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

 

=={{header|MATLAB}}==

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 =

Column 5

 

 

=={{header|Maxima}}==

 

map(sin, [1, 2, 3, 4]);

/* for matrices */

 

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

BEGIN

Map(sample, NUMBER(sample), callback);

 

=={{header|Nanoquery}}==

numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// display the squared list

{{out}}

<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

=={{header|Nemerle}}==

The <tt>Nemerle.Collections</tt> namespace defines the methods <tt>Iter()</tt> (if the function applied is <tt>void</tt>) and <tt>Map()</tt> (if the function applied returns a value).

 

=={{header|NetLogo}}==

;; NetLogo “anonymous procedures”

;; stored in a variable, just to show it can be done.

let callback [ [ x ] x * x ]

show (map callback [ 1 2 3 4 5 ])

 

=={{header|NewLISP}}==

 

(1 4 9 16)

 

=={{header|NGS}}==

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

 

=={{header|Nial}}==

 

 

=={{header|Nim}}==

 

 

{{Out}}

=={{header|Oberon-2}}==

{{Works with|oo2x}}

MODULE ApplyCallBack;

IMPORT

Init(a);r := Map3(Fun3,a);Show(r^);

END ApplyCallBack.

{{Out}}

<pre>

 

=={{header|Objeck}}==

use Structure;

 

}

}

 

=={{header|OCaml}}==

This function is part of the standard library:

 

 

Usage example:

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

 

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

 

Use <tt>iter</tt> if the applied function does not return a value.

 

 

with partial application we can also write:

 

 

=={{header|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 <tt>arrayfun</tt> can be used.

 

e = x^2 + exp(-1/(y+1));

endfunction

% f([2,3], [1,4]) gives and error, but

arrayfun(@f, [2, 3], [1,4])

 

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

=={{header|Oforth}}==

apply allows to perform a function on all elements of a list :

 

map regroups all results into a new list :

 

=={{header|Ol}}==

Apply custom callback (lambda) to every element of list.

(for-each

(lambda (element)

'(1 2 3 4 5))

; ==> 12345

 

=={{header|ooRexx}}==

ooRexx doesn't directly support callbacks on array items, but this is pretty easy to implement using Routine objects.

new = map(start, .routines~reversit)

call map new, .routines~sayit

use arg string

say string

{{out}}

<pre>kciR

=={{header|Order}}==

Both sequences and tuples support the usual map operation seen in many functional languages. Sequences also support <code>8seq_for_each</code>, and a few variations, which returns <code>8nil</code>.

 

ORDER_PP( 8tuple_map(8fn(8X, 8times(8X, 8X)), 8tuple(1, 2, 3, 4, 5)) )

 

ORDER_PP( 8seq_for_each(8fn(8X, 8print(8X 8comma)), 8seq(1, 2, 3, 4, 5)) )

 

=={{header|Oz}}==

fun{Square A}

A*A

%% apply a FUNCTION to every element

Result = {Map Lst Square}

 

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.4.2 and above}}

 

This should be contrasted with <code>call</code>:

which is equivalent to <code>callback(1, 2, 3, 4, 5)</code> rather than <code>[callback(1), callback(2), callback(3), callback(4), callback(5)]</code>.

 

 

=={{header|Perl}}==

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

 

 

# filter an array

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.2"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},</span><span style="color: #000000;">add1</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

by Galileo, 05/2022 #/

 

getid square map

 

{{out}}

<pre>

 

=={{header|PHP}}==

{

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

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

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

 

=={{header|Picat}}==

Picat doesn't support anonymous (lambda) functions so the function must be defined in the program to be used by - say - map/2.

There are - however - quite a few ways without proper lambdas, using map/2, apply/2, or list comprehensions.

L = 1..10,

 

% Some function

fun(X) = X*X.

 

{{trans|Prolog}}

 

Note that fun2/2 is not a function so map/2 or apply/2 cannot be used here.

L = 1..10,

 

println([B : A in L, bp.fun2(A,B)]),

nl.

 

Using this technique one can do quite much "real" Prolog stuff even though Picat doesn't support it directly. However, one should be careful with this approach since it can sometimes be confusing and it doesn't work in all cases.

 

=={{header|PicoLisp}}==

1

2

 

: (mapcar if '(T NIL T NIL) '(1 2 3 4) '(5 6 7 8)) # Conditional function

 

=={{header|Pike}}==

{

return n*n*n;

array(int) a = ({ 1,2,3,4,5 });

array(int) b = cube(a[*]); // automap operator

 

=={{header|PL/I}}==

x = sqrt(x);

 

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

PL/SQL doesn't have callbacks, though we can pass around an object and use its method to simulate one. Further, this callback method can be defined in an abstract class that the mapping function will expect.

create or replace

TYPE callback AS OBJECT (

PKG_CALLBACK.TEST_CALLBACK();

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

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

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 <code>[]</code>:

 

{{libheader|initlib}}

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

 

=={{header|PowerShell}}==

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

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

$a | ForEach-Object $s

}

 

=={{header|Prolog}}==

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

true.

 

?- maplist(fun, [1,2,3,4,5], L).

L = [2,4,6,8,10].

 

=={{header|PureBasic}}==

Protected n.i

For n = 0 To ArraySize(param())

Next

 

 

=={{header|Python}}==

return n * n

 

import itertools

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

Or:

Result:

 

=={{header|QB64}}==

'Task

'Take a combined set of elements and apply a function to each element.

End Sub

 

 

=={{header|Quackery}}==

As a dialogue in the Quackery shell (REPL), applying the word <code>cubed</code> to the nest <code>[ 1 2 3 4 5 6 7 8 9 10 ]</code>, first treating the nest as a list, then as an array.

 

...

 

...

 

 

=={{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 *apply] family of functions.

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

1 8 27 64 125

=={{header|Racket}}==

 

#lang racket

 

;; the usual functional `map'

(vector-map sqr #(1 2 3 4 5))

 

=={{header|Raku}}==

{{works with|Rakudo|2015.10-11}}

 

my @array = 1 .. 5;

 

# we neither need a variable for the array nor for the function

say [1,2,3]>>.&({ $^x + 1});

 

=={{header|Raven}}==

 

group [1 2 3 4 5] each

dup *

 

=={{header|REBOL}}==

Title: "Array Callback"

URL: http://rosettacode.org/wiki/Apply_a_callback_to_an_Array

 

print [crlf "Applying native function with 'map':"]

 

{{Out}}

Retro provides a variety of array words. Using these to multiply each value in an array by 10 and display the results:

 

 

=={{header|REXX}}==

numeric digits 100 /*be able to display some huge numbers.*/

parse arg # . /*obtain an optional value from the CL.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

fact: procedure; arg x; != 1; do f=2 to x; != !*f; end; /*f*/; return !

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

for x in [1,2,3,4,5]

x = x*x

next

 

=={{header|RLaB}}==

Consider an example:

 

>> x = rand(2,4)

0.707213207 0.275298961 0.396757763 0.232312312

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

}

}

 

 

function 'members' which returns a string vector with the names of the elements of the list.

 

x = <<>>;

for (i in 1:9)

y.[i] = sin( x.[i] );

}

 

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

 

println!("{}", n);

}

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

let _: Vec<_> = a.into_iter().map(echo).collect();

 

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

 

(comprehend(x; list) (to_apply(x)));

 

 

iterate(x; apply([0...9], square))

 

With short identifiers:

 

 

fun apply(list, ageless to_apply)

 

iter(x; apply([0...9], square))

 

With the numbers given as a list of individual elements:

 

(comprehend(x; list) (to_apply(x)));

 

 

iterate(x; apply([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], square))

 

=={{header|Sather}}==

do_something(i:INT):INT is

return i * i;

loop #OUT + a.elt! + "\n"; end;

end;

 

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

put each item in [1,2,3,5,9,14,24] squared

 

to handle myFunc of num

return 2*num + 1

Output:

 

=={{header|Sidef}}==

Defining a callback function:

 

The function will get called for each element:

 

Same as above, but with the function inlined:

 

For creating a new array, we can use the Array.map method:

 

=={{header|Simula}}==

 

! APPLIES A CALLBACK FUNCTION TO AN ARRAY ;

FOR I := 1 STEP 1 UNTIL 5 DO OUTFIX(A(I), 2, 8); OUTIMAGE;

 

{{out}}

<pre>

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

You can tell symbols how to react to the <tt>value:</tt> message, and then write &sup2;:

2) actually most dialects already have it, and it is trivial to add, if it does not.

 

There is a huge number of additional enumeration messages implemented in Collection, from which Array inherits. Eg.:

 

=={{header|Sparkling}}==

The <tt>foreach</tt> function calls the supplied callback on each element of the (possibly associative) array, passing it each key and the corresponding value:

foreach(numbers, function(idx, num) {

print(num);

 

The <tt>map</tt> function applies the transform to each key-value pair and constructs a new array, of which the keys are the keys of the original array, and the corresponding values are the return values of each call to the transform function:

let doubled = map(dict, function(key, val) {

return val * 2;

 

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

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

END;

END @

Output:

<pre>

 

=={{header|Standard ML}}==

map f l

i.e.

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

 

=={{header|Stata}}==

There is no 'map' function in Mata, but it's easy to implement. Notice that you can only pass functions that are written in Mata, no builtin ones. For instance, the trigonometric functions (cos, sin) or the exponential are builtin. To pass a builtin function to another function, one needs to write a wrapper in Mata. See also Stata help about '''[https://www.stata.com/help.cgi?m2_pointers pointers]''' and '''[https://www.stata.com/help.cgi?m2_ftof passing functions to functions]'''. There are two versions of the function: one to return a numeric array, another to return a string array.

 

nr = rows(a)

nc = cols(a)

function square(x) {

return(x*x)

 

'''Output'''

=={{header|SuperCollider}}==

Actually, there is a builtin <tt>squared</tt> operator:

Anything that is a <tt>Collection</tt> can be used with <tt>collect</tt>:

[[List Comprehension#SuperCollider|List comprehension]] combined with a higher-order function can also be used:

var map = { |fn, xs|

all {: fn.value(x), x <- xs };

};

 

=={{header|Swift}}==

return n * n

}

let squares1b = numbers.map { $0 * $0 } // map method on array with anonymous function and unnamed parameters

 

 

=={{header|Tailspin}}==

def numbers: [1,3,7,10];

 

[ $numbers... -> $ * $ ] -> !OUT::write

[ $numbers... -> cube ] -> !OUT::write

 

=={{header|Tcl}}==

 

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

myfunc $var

This does not retain any of the values returned by <tt>myfunc</tt>.

 

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

myfunc $dat($name)

 

More functional, with a simple <code>map</code> function:

set res {}

foreach e $list {lappend res [$f $e]}

 

% map square {1 2 3 4 5}

 

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

 

Define foreach(fe_cname,fe_list) = Prgm

Local fe_i

 

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

 

{{Out}}

JavaScript alike:

 

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

 

Using short form of lambda notation:

a.map( :v: v*v );

 

=={{header|Toka}}==

 

{

value| array fn |

 

( Add 1 to each item in the array )

 

=={{header|TorqueScript}}==

Callbacks:

 

function map(%array,%arrayCount,%function)

{

}

}

 

Now to set up an array:

 

$array[0] = "Hello.";

$array[1] = "Hi.";

$array[2] = "How are you?";

 

Now to call the function correctly:

 

map("$array",3,"echo");

 

Which should result in:

 

=> Hello.

 

 

=> How are you?

 

=={{header|TXR}}==

Print 1 through 10 out of a vector, using <code>prinl</code> the callback, right from the system shell command prompt:

 

1

2

8

9

 

<code>mapdo</code> is like <code>mapcar</code> but doesn't accumulate a list, suitable for imperative programming situations when the function is invoked to perform a side effect.

Push 10000+((Pop()*-(Pop()/2))/10000)

If a@ Then Push -Pop() ' Result is directly transferred

{{out}}

<pre>SQRT(1) = 1.0000

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

map_command=$1

shift

}

list=1:2:3

 

{{works with|ksh93}}

{{works with|pdksh}}

{{works with|zsh}}

typeset command=$1

shift

}

set -A ary 1 2 3

 

{{works with|zsh}}

a=(1 2 3)

 

=={{header|Ursala}}==

The * is a built-in map operator.

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

 

#cast %nL

 

{{Out}}

<pre>

=={{header|V}}==

apply squaring (dup *) to each member of collection

 

=={{header|VBA}}==

Option Explicit

 

Fibonacci = Fibonacci(N - 1) + Fibonacci(N - 2)

End If

{{out}}

<pre>0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55</pre>

 

=====Implementation=====

class callback

dim sRule

end function

end class

 

=====Invocation=====

dim a1

dim cb

cb.applyto a1

wscript.echo join( a1, ", " )

 

{{Out}}

The result of evaluating the string will be the new value.

The list/dictionary is modified in place.

echo map([10, 20, 30], '"Element " . v:key . " = " . v:val')

echo map({"a": "foo", "b": "Bar", "c": "BaZ"}, 'toupper(v:val)')

 

{{Out}}

and System.Linq.Enumerable.ToArray(Of TSource)(IEnumerable(Of TSource)) eagerly converts the enumerable to an array.

 

Function OneMoreThan(i As Integer) As Integer

Return i + 1

Array.ForEach(resultArr, AddressOf Console.WriteLine)

End Sub

 

{{out}}

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

 

=={{header|Wart}}==

 

{{Out}}

 

=={{header|WDTE}}==

let s => import 'stream';

 

-> s.map (* 2)

-> s.collect

 

In WDTE, mapping can be accomplished using the <code>stream</code> module. Streams are essentially lazy iterators. The <code>arrays</code> module provides a function for creating a stream from an array, and then the <code>stream</code> module's functions can be used to perform a map operation. <code>collect</code> runs the iteration, collecting the elements yielded in a new array.

 

=={{header|Wren}}==

arr = arr.map { |x| x * 2 }.toList

arr = arr.map(Fn.new { |x| x / 2 }).toList

 

{{out}}

 

=={{header|XBS}}==

set newArr:array = [];

foreach(k,v as arr){

log(arr.join(", "));

{{out}}

<pre>

 

=={{header|Yabasic}}==

local i

 

print t(i), "\t";

next i

 

=={{header|Yacas}}==

 

MapSingle(Sin, {1,2,3,4})

 

MapSingle({{x}, x^2}, {1,2,3,4})

 

=={{header|Z80 Assembly}}==

byte &01,&02,&03,&04,&05

Array_End:

inc (hl)

inc hl ;next entry in array

 

{{out}}

 

=={{header|Zig}}==

var array = [_]i32{1, 2, 3};

apply(@TypeOf(array[0]), array[0..], func);

const std = @import("std");

std.debug.print("{d}\n", .{a-1});

 

=={{header|zkl}}==

{{Out}}

<pre>

 

=={{header|zonnon}}==

module Main;

type

Write(Map(x,Power))

end Main.

{{Out}}

<pre>

 

=={{header|ZX Spectrum Basic}}==

20 LET b$="x*x"

30 LET c$="x+x^2"

190 STOP

200 DATA 2,5,6,10,100

 

{{omit from|gnuplot}}