Apply a callback to an array: Difference between revisions

[[Category:Iteration]]

 

;Task:

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

{{trans|Kotlin}}

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

print(arrsq)</syntaxhighlight>

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

 

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

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

The builtin word "a:map" does this:

[ 1 , 2, 3 ]

' n:sqr

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

 

(if (endp xs)

nil

 

=={{header|ActionScript}}==

{

public class ArrayCallback

=={{header|Ada}}==

{{works with|GNAT|GPL 2005}}

with Ada.Integer_text_IO;

 

=={{header|Aime}}==

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

{

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

 

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

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

 

=={{header|AppleScript}}==

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

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

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}

 

=={{header|Arturo}}==

 

print map arr => [2*&]</syntaxhighlight>

 

=={{header|AutoHotkey}}==

 

callback(array){

 

=={{header|AWK}}==

4 16

5 25

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

2.23606798

</pre>

 

=={{header|Bracmat}}==

= location value

. !arg:(?location,?value)

=={{header|Brat}}==

 

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

p element

Alternatively:

 

 

=={{header|C}}==

 

'''callback.h'''

#define CALLBACK_H

 

 

'''callback.c'''

#include "callback.h"

 

This version uses the C# 3 lambda notation.

 

// Simplest method: LINQ, functional

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

 

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

 

static class Program

{{works with|g++|4.1.1}}

===C-Style Array===

#include <algorithm> //for_each defined here

 

===std::vector===

{{libheader|STL}}

#include <algorithm> // for_each defined here

#include <vector> // stl vector class

 

More tricky with binary function

#include <algorithm> // for_each defined here

#include <vector> // stl vector class

===Boost.Lambda===

{{libheader|Boost}}

using namespace boost::lambda;

vector<int> ary(10);

 

===C++11===

#include <iostream>

#include <algorithm>

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.

 

Start = mapArray square values</syntaxhighlight>

 

=={{header|Clio}}==

'''Math operations'''

'''Quick functions'''

'''Anonymous function'''

-> * fn n:

n * 2 + 1

-> print</syntaxhighlight>

'''Named function'''

n * 2 + 1

 

=={{header|Clojure}}==

 

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

 

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

 

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

 

=={{header|CLU}}==

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

% it will work for any type of element.

 

=={{header|COBOL}}==

Basic implementation of a map function:

 

 

 

 

=={{header|CoffeeScript}}==

map = (arr, f) -> (f(e) for e in arr)

arr = [1, 2, 3, 4, 5]

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

 

 

Functional: collect squares into new vector that is returned:

 

(map 'vector #'square #(1 2 3 4 5))</syntaxhighlight>

 

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

 

(map-into *a* #'1+ *a*)</syntaxhighlight>

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Callback;

IMPORT StdLog;

=={{header|Crystal}}==

Calling with a block

 

new_values = values.map do |number|

 

Calling with a function/method

 

def double(number)

 

=={{header|D}}==

 

void main() {

 

=={{header|Delphi}}==

// Declare the callback function

procedure callback(const AInt:Integer);

=={{header|Dyalect}}==

 

let ys = []

for x in this when pred(x) {

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

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

 

#implemented roughly like this:

=={{header|E}}==

 

def square(value) {

return value * value

Example of builtin iteration:

 

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

}

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

 

def output := [].diverge()

for item in collection {

 

=={{header|EchoLisp}}==

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

→ #( 0 2 4 7)

=={{header|Efene}}==

 

N * N

}

 

=={{header|EGL}}==

 

program ApplyCallbackToArray

 

=={{header|Elena}}==

 

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

public program()

{

}</syntaxhighlight>

 

=={{header|Elixir}}==

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

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

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

PROGRAM CALLBACK

 

 

=={{header|Euphoria}}==

-- apply a function to all elements of a sequence

sequence result

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

let result = Array.map evenp [| 1; 2; 3; 4; 5; 6 |]</syntaxhighlight>

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

{

=={{header|FBSL}}==

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

 

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

 

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

 

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

----------------------------------------

Press any key to continue...</pre>

 

=={{header|Forth}}==

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

 

-rot cells bounds do i @ over execute i ! cell +loop ;</syntaxhighlight>

 

{{Out|Example usage}}

data 5 ' 1+ map \ adds one to each element of data</syntaxhighlight>

 

 

{{Works with |Fortran|ISO 95 and later}}

contains

elemental function cube( x )

end module arrCallback</syntaxhighlight>

 

use arrCallback

implicit none

 

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

C

C-- Declare array:

 

=={{header|FP}}==

& square: <1,2,3,4,5></syntaxhighlight>

 

=={{header|FreeBASIC}}==

 

Sub PrintEx(n As Integer)

 

=={{header|Frink}}==

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

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

 

=={{header|FunL}}==

 

[1, 2, 3].foreach( a -> println(2a) )</syntaxhighlight>

 

=={{header|Futhark}}==

map f l

</syntaxhighlight>

e.g.

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

</syntaxhighlight>

or equivalently

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

</syntaxhighlight>

 

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

 

 

 

 

=={{header|GAP}}==

b := ShallowCopy(a);

 

 

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

 

import "fmt"

 

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"

 

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]

map square values</syntaxhighlight>

 

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

printSquares values</syntaxhighlight>

 

===Array===

{{works with|GHC|7.10.3}}

 

square :: Int -> Int

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

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

 

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.

 

=={{header|Java}}==

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

 

 

interface IntConsumer {

{{works with|Java|8}}

 

 

public class ArrayCallback {

 

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

 

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

</syntaxhighlight>Here is a transcript illustrating how the last of these jq expressions can be evaluated:

[0, 1 , 10]

[1,2,11]</syntaxhighlight>

 

=={{header|Jsish}}==

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

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

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

 

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

 

=={{header|Klingphix}}==

 

( 1 2 3 4 ) [dup *] map

 

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

</syntaxhighlight>

 

=={{header|Lang5}}==

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

[1 2 3 4 5] 'square apply . "\n" .</syntaxhighlight>

 

=={{header|langur}}==

 

{{out}}

 

=={{header|Lasso}}==

 

local(

 

=={{header|Lisaac}}==

+ b : {INTEGER;};

 

 

=={{header|Logo}}==

output :x * :x

end

 

Say we have an array:

A map function for this would be

local result = {}

for k,v in ipairs(data) do

end</syntaxhighlight>

Together with our array and a square function this yields:

 

print(unpack( map(myFunc, myArray) ))

 

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

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

b=lambda->{

 

=={{header|M4}}==

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

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

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]

</syntaxhighlight>

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]

</syntaxhighlight>

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]

 

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

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

[4, 5, 6]

</syntaxhighlight>

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]

 

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

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

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

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 =

 

=={{header|Maxima}}==

 

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

=={{header|min}}==

{{works with|min|0.19.3}}

(1 2 3 4 5) 'sqrt map ; collect return values</syntaxhighlight>

 

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

 

IMPORT IO, Fmt;

 

=={{header|Nanoquery}}==

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

def squares = seq.Map(x => x*x);</syntaxhighlight>

 

=={{header|NetLogo}}==

;; NetLogo “anonymous procedures”

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

=={{header|NewLISP}}==

 

(1 4 9 16)

</syntaxhighlight>

 

=={{header|NGS}}==

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

}</syntaxhighlight>

=={{header|Nial}}==

 

=1 4 9 16</syntaxhighlight>

 

=={{header|Nim}}==

 

 

{{Out}}

3 squared = 9

4 squared = 16

 

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

{{Works with|oo2x}}

MODULE ApplyCallBack;

IMPORT

 

=={{header|Objeck}}==

use Structure;

 

This function is part of the standard library:

 

 

Usage example:

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

Array.map square values;;</syntaxhighlight>

 

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

List.map square values;;</syntaxhighlight>

 

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

 

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

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

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

 

=={{header|Oz}}==

fun{Square A}

A*A

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

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

apply(callback, [1,2,3,4,5])</syntaxhighlight>

 

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

 

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

 

=={{header|Phixmonti}}==

by Galileo, 05/2022 #/

 

 

=={{header|PHP}}==

{

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

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,

 

 

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

L = 1..10,

 

 

=={{header|PicoLisp}}==

1

2

 

=={{header|Pike}}==

{

return n*n*n;

 

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

x = sqrt(x);

x = sin(x);</syntaxhighlight>

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

=={{header|Pop11}}==

 

define proc(x);

printf(x*x, '%p,');

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

</syntaxhighlight>

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

 

 

=={{header|PureBasic}}==

Protected n.i

For n = 0 To ArraySize(param())

 

=={{header|Python}}==

return n * n

isquares2 = itertools.imap(square, numbers) # iterator, lazy</syntaxhighlight>

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.

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

cubes <- cube(elements)</syntaxhighlight>

Explicit looping over array elements is also possible.

for(i in seq_along(cubes))

{

}</syntaxhighlight>

Loop syntax can often simplified using the [http://stat.ethz.ch/R-manual/R-patched/library/base/html/apply.html *apply] family of functions.

cubes <- sapply(elements2, cube)</syntaxhighlight>

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

=={{header|Racket}}==

 

#lang racket

 

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

 

my @array = 1 .. 5;

 

 

=={{header|Raven}}==

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

 

group [1 2 3 4 5] each

dup *

 

=={{header|REBOL}}==

Title: "Array Callback"

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

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.*/

 

=={{header|Ring}}==

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

x = x*x

Consider an example:

 

>> x = rand(2,4)

0.707213207 0.275298961 0.396757763 0.232312312

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

}

</syntaxhighlight>

 

=={{header|Ruby}}==

You could use a traditional "for i in arr" approach like below:

puts i**2

end</syntaxhighlight>

 

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

}

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

 

With short identifiers:

 

 

fun apply(list, ageless to_apply)

With the numbers given as a list of individual elements:

 

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

 

 

=={{header|Sather}}==

do_something(i:INT):INT is

return i * i;

 

=={{header|Scala}}==

l.foreach {i => println(i)}</syntaxhighlight>

 

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

a.foreach(println(_)) '' // same as previous line''</syntaxhighlight>

 

Or for an externally defined function:

l.foreach(doSomething)</syntaxhighlight>

 

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

(map square (vector->list x))</syntaxhighlight>

 

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

 

end myFunc</syntaxhighlight>

Output:

(3,5,7,11,19,29,49)</syntaxhighlight>

 

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

 

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

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

With SQL PL:

--#SET TERMINATOR @

 

 

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

map f l

</syntaxhighlight>

i.e.

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

</syntaxhighlight>

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)

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

}

 

=={{header|Tailspin}}==

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

 

 

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

myfunc $var

}</syntaxhighlight>

 

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

myfunc $dat($name)

}</syntaxhighlight>

 

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

set res {}

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

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

 

Define foreach(fe_cname,fe_list) = Prgm

Local fe_i

JavaScript alike:

 

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

</syntaxhighlight>

 

Using short form of lambda notation:

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

</syntaxhighlight>

=={{header|Toka}}==

 

{

value| array fn |

Callbacks:

 

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

{

Now to set up an array:

 

$array[0] = "Hello.";

$array[1] = "Hi.";

Now to call the function correctly:

 

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

</syntaxhighlight>

Which should result in:

 

=> Hello.

 

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

 

1

2

=={{header|uBasic/4tH}}==

We cannot transfer the array address, since uBasic/4tH has only got one, but we can transfer the function pointer and size.

 

For x = 0 To S - 1 ' Initialize array

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

{{works with|Bourne Shell}}

map_command=$1

shift

{{works with|pdksh}}

{{works with|zsh}}

typeset command=$1

shift

 

{{works with|zsh}}

a=(1 2 3)

map print $a</syntaxhighlight>

The * is a built-in map operator.

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

 

#cast %nL

=={{header|V}}==

apply squaring (dup *) to each member of collection

 

=={{header|VBA}}==

Option Explicit

 

 

=====Implementation=====

class callback

dim sRule

 

=====Invocation=====

dim a1

dim cb

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

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

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

 

 

=={{header|Wren}}==

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

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

 

=={{header|XBS}}==

set newArr:array = [];

foreach(k,v as arr){

 

=={{header|Yabasic}}==

local i

 

 

=={{header|Yacas}}==

 

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

 

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

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

Array_End:

 

=={{header|Zig}}==

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

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

 

=={{header|zkl}}==

{{Out}}

<pre>

 

=={{header|zonnon}}==

module Main;

type

 

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

20 LET b$="x*x"

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