How to Map a function on just one entry in a list?

0
votes

I have been learning to use Map more (to become more functional programmer). It looks like Map wants a list as the expression to apply the function to. If the expression is not a list, then it is not happy.

I use NumberForm in this example to illustrate what I mean:

I can Map NumberForm on the whole list ok:

data = {1, 2, 3}
Map[NumberForm[#, {3, 2}] &, data]

But if I try to Map it to some specific element in the list, say the first one in the above, it does not work

data = {1, 2, 3}
Map[NumberForm[#, {3, 2}] &, data[[1]] ]

The result returned is NOT formatted. Same as original data. i.e I get back '1' and not '1.00' as in the other examples.

To solve, I added extra {}

data = {1, 2, 3}
Map[NumberForm[#, {3, 2}] &, {data[[1]]} ]

it works now, (just need to remove the {} from the result using First).

So I thought, then why not add this extra {} all the time and remove it in the end? This way, I do not have to worry if what I am Map'ing function to happened to be not a list like in the above example?

So, my examples will all becomes like this:

data = {1, 2, 3}
First@Map[NumberForm[#, {3, 2}] &, { data } ]
First@Map[NumberForm[#, {3, 2}] &, { data[[1]] } ]

This way, code will works on everything and I do not have to make special check before using Map if what I happened to be applying Map to is a list or not.

Question is: Does the the above look an OK solution for the experts, or is there a better way to handle this?

4
wolfram-mathematica
I have to confess, I don't understand what your motivation is for asking this question. Why would you ever try to Map on to something which is not a list? - David Z
@David Zaslavsky One may eventually want to Map on something else than a list, but this is rather rare and anyways done in situations different from the one discussed in this question. A typical example would be something like Map[f, myContainerA[myContainerB[1, 2, 3], myContainerC[4, 5, 6]], {2}], although in cases like that I usually use rules. - Leonid Shifrin
Perhaps I am misunderstanding your question, but does my approach not answer it? If not, could you try to explain in a different way what you want? It seems to me that my suggestion does exactly what you want. - acl
I see you accepted acl's answer. Be careful with the map function he shows, just as I said for my use of levelspec {-1}. If you use map[f, Sqrt[2]] you will see that this may not be what you want. I still believe there is a deeper issue of method implicit in your question that has not been well addressed. - Mr.Wizard
To say that a different way, you asked: "Does the above look an OK solution for the experts, or is there a better way to handle this?" I say no, it does not look like an OK solution generally, and neither does acl's map or my Map[f, x, {-1}]. Would you please consider adding some use context to your question, that we may better recommend an approach? - Mr.Wizard

4 Answers

4
votes

Perhaps I'm not understanding your intent here, but if you're looking Map a function on just a particular entry in a list, then MapAt is the function you're looking for. Example:

MapAt[NumberForm[#, {3, 2}] &, data, 1]
Out[1]= {1.00,2,3}

Here, the function has been applied to only the first element in the list.

2
votes

This only happens to work because NumberForm works on lists:

NumberForm[{1, 2, 3}, {3, 2}]

gives

{1.00, 2.00, 3.00}

Map[f, {{a, b, c}}] simply maps f onto First[{{a,b,c}}], namely, onto {a,b,c}; so you get f[{a,b,c}].

So unfortunately adding {} will not work in general.

A simple way to do this is to define

ClearAll[map]
map[f_, head_[els__]] := Map[f, head[els]]
map[f_, el_] := f[el]

whence

map[f, {a, b, c}]
map[f, a]

give

{f[a], f[b], f[c]}
f[a]

However this does not allow for the Map[f,expr,levelspec] form (which however is easy enough to implement).

This also works in this case:

map[f, g[a, b, c]] == Map[f, g[a, b, c]]
(*
True
*)
2
votes

This seems like an odd question. Why write First@Map[f, { x } ] when you can just write f @ x?

How does it come to be that the second argument of Map may be either form?

Perhaps you would find value in mapping by levels from the end:

Map[f, {x, y, z}, {-1}]

Map[f, x, {-1}]

Be careful with this, as if the list elements are not atomic, you will get unexpected results.

Alternatively, you might write:

data = {1, 2, 3};

data /. n_?NumberQ :> NumberForm[n, {3, 2}]

data[[1]] /. n_?NumberQ :> NumberForm[n, {3, 2}]
2
votes

I see a few different questions

  1. What are the different ways to Map? Not surprisingly, because lists are fundamental to the operation of Mathematica, there are many ways to transform them. However, there isn't any direct way that I can see to tell Mathematica that, given f and {l1, l2, ...} to give me {f@l1, l2, ...}. If you want to apply f to the first element of l (for example, to test before applying f to all of l) you can also do f/@l[[1;;1]]. (edit @yoda mentions that MapAt has this behavior, one can specify a set of positions where one should map).
  2. How to deal with an operand that implements the Composite pattern (ie, is either an element of type t or a list of elements of type t)? The natural way to do this in Mathematica is to give your operator the Listable attribute. Then if we define: f[a_AtomicType], f[a:{_AtomicType..}] gives the results of f/@a

Edit -- Actually, given f[a_AtomicType]:=something, f[a_List] gives the results of f/@a even if some elements of a don't have head AtomicType -- ie Listable functions don't verify that all elements of the list have a transformation rule in terms of f. If you care about this you would need to separately define f[a:{_AtomicType..}]:=f/@a and not make your function Listable.

Also, @Nasser, it looks like the behavior in your first example is because Map[f,a_AtomicType] returns a. Also note that Map can map over expressions with any head, not just List.