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