Question

I want to define a symbol and use it within a function. For example, with IDnumbers defined as a list of numbers:

ParallelMap[{#1, Name[#1], Age[#1]} &, IDnumbers]

With userlist={#1, Name[#1], Age[#1]} becomes:

ParallelMap[userlist &, IDnumbers]

It works just fine with the list itself in the code, but not with the symbol. The same thing happens with a list of strings vs. a symbol assigned to a list of strings. Why is this?

Answer 1

Since f[#]& is shorthand for Function[f[#]] you should always complete your anonymous function with a trailing & to get a working function.
In your example:

userlist={#1, Name[#1], Age[#1]}&
ParallelMap[userlist, IDnumbers]

More thorough explanation:

By just using something like f[#] you get (in FullForm[])

In[15]            := f[#] // FullForm
Out[15]//FullForm  = f[Slot[1]]

whereas this gets transformed to a Function by the trailing & operator:

In[16]            := f[#]& // FullForm
Out[16]//FullForm  = Function[f[Slot[1]]]

If you do this in two steps, & doesn’t evaluate the intermediate variable expr:

In[25]:= expr = f[#]//FullForm
In[26]:= expr &
Out[25]//FullForm = f[Slot[1]]
Out[26]           = expr &

You can force the evaluation of expr before it gets wrapped in the Function[] by using Evaluate[]:

In[27]:= expr=f[#]//FullForm
In[28]:= Evaluate[expr]&
Out[27]//FullForm = f[Slot[1]]
Out[28]           = f[Slot[1]]&

Another way is to supply the Function[] wrapper yourself:

userlist={#1, Name[#1], Age[#1]}
ParallelMap[Function[userlist], IDnumbers]

Personally, i would consider this bad coding style. Just get used to always finishing an anonymous function with a trailing & like you would supply a closing paranthesis ) to a corresponding opening one (.

Edit
Ok, in your case of a dynamically generated anonymous function i can see why you couldn’t supply the & directly. Just wrap the expression with the Slot[]s in a Function[] instead.