The map commands apply fcn to the operands or elements of expr.

map(fcn, expr, arg1, ..., argN) executes fcn(elem, arg1, ..., argN) for each operand or element of expr.  Similarly, map2(fcn, arg1, expr, arg2, ..., argN) executes fcn(arg1, elem, arg2, ..., argN) for each operand or element of expr, and map[3](fcn, arg1, arg2, expr, arg3, ..., argN) executes fcn(arg1, arg2, elem, arg3, ..., argN) for each operand or element of expr.

The result of a call to map is a copy of expr with the ith operand of expr replaced by the result of applying fcn to the ith operand.  This is done for all the operands of expr. For expressions of type atomic, map(fcn, expr) is identical to fcn(expr). For a table or rtable (such as Array, Matrix, or Vector), fcn is applied to each element instead of each operand.

If fcn takes more than one argument, they are to be specified as additional arguments, arg2, arg3, ..., argn, which are simply passed through as the second, third, ..., nth arguments to fcn.

If expr has no elements (or operands) then it is returned as is. For example, map(f, [ ]) returns the empty list [ ].

Some options can be specified in square brackets as an index to the map command.  These options can be used by themselves or in combination with other options.

The evalhf option only applies when mapping over an rtable.  Prior to applying the map function, a copy of the original rtable is made with datatype=float[8] storage. Each application of fcn is evaluated using evalhf, which works only in the hardware float domain.

The inplace option only applies when mapping over a rectangular storage rtable with no indexing function. When inplace is specified, the input rtable is updated in-place.  The result is the updated original expr rtable, rather than a copy.

Since strings are atomic expressions in Maple, you cannot map a procedure over a string by using map. However, the StringTools package provides a Map export that delivers this functionality.

The map and map2 commands are thread safe, provided that evaluating the expression fcn is thread safe

For more information on thread safety, see index/threadsafe.

$\mathrm{map}\left(f\,x+yz\right)$

$f\left(yz\right)+f\left(x\right)$

$\mathrm{map}\left(f\,yz\right)$

$f\left(y\right)f\left(z\right)$

$\mathrm{map}\left(f\,\left\{a\,b\,c\right\}\right)$

$\left\{f\left(a\right)\,f\left(b\right)\,f\left(c\right)\right\}$

$\mathrm{map}\left(x\mapsto x^2\,x+y\right)$

$x^2+y^2$

map(proc(x,y) x^2+y end proc, [1,2,3,4], 2);

$\left[3\,6\,11\,18\right]$

$\mathrm{map2}\left(f\,g\,\left\{a\,b\,c\right\}\right)$

$\left\{f\left(g\,a\right)\,f\left(g\,b\right)\,f\left(g\,c\right)\right\}$

$\mathrm{map2}\left(\mathrm{op}\,1\,\left[a+b\,c+d\,e+f\right]\right)$

$\left[a\,c\,e\right]$

$\mathrm{NumberOfAbelianGroups}≔n::\'\mathrm{posint}\'\mapsto \mathrm{mul}\left(k\,k=\mathrm{map}\left(\mathrm{combinat}:-\mathrm{numbpart}\,\mathrm{map2}\left(\mathrm{op}\,2\,\mathrm{ifactors}\left(n\right)\left[2\right]\right)\right)\right)$

$\mathrm{NumberOfAbelianGroups}≔n::?\mapsto \mathrm{mul}\left(k\,k=\mathrm{map}\left(\mathrm{combinat}:-\mathrm{numbpart}\,\mathrm{map2}\left(\mathrm{op}\,2\,{\mathrm{ifactors}\left(n\right)}_2\right)\right)\right)$

$\mathrm{NumberOfAbelianGroups}\left(4\right)$

$2$

$\mathrm{NumberOfAbelianGroups}\left(6\right)$

$1$

$\mathrm{NumberOfAbelianGroups}\left(768\right)$

$22$

sum_to_product:=proc(expr)
  if expr::atomic then
    expr;
  elif expr::`+` then
    `*`(op(expr));
  else
   map(procname,expr);  end if;
end proc:

$\mathrm{sum\_to\_product}\left(3+4x^2+3\left(x+2\right){\left(x+7\right)}^2\right)$

$36x^2\left(x+2\right){\left(x+7\right)}^2$

$A≔\mathrm{Array}\left(\left[1\,2\,3\,4\right]\,\mathrm{datatype}=\mathrm{float}\left[8\right]\right)$

$A≔\left[\begin{array}{cccc}1.& 2.& 3.& 4.\end{array}\right]$

$\mathrm{map}\left[\mathrm{evalhf},\mathrm{inplace},2\right]\left(\left(a\,b\right)\mapsto a^b\,2\,A\right)$

$\left[\begin{array}{cccc}2.& 4.& 8.& 16.\end{array}\right]$

$A\left[1\right]$

$2.$