Attributes

Definitions such as specify values for functions. Sometimes, however, you need to specify general properties of functions, without necessarily giving explicit values.

Mathematica provides a selection of attributes that you can use to specify various properties of functions. For example, you can use the attribute Flat to specify that a particular function is "flat", so that nested invocations are automatically flattened, and it behaves as if it were associative.

This assigns the attribute Flat to the function .
In[1]:=
Click for copyable input
Now behaves as a flat, or associative, function, so that nested invocations are automatically flattened.
In[2]:=
Click for copyable input
Out[2]=

Attributes like Flat can affect not only evaluation, but also operations such as pattern matching. If you give definitions or transformation rules for a function, you must be sure to have specified the attributes of the function first.

Here is a definition for the flat function .
In[3]:=
Click for copyable input
Because is flat, the definition is automatically applied to every subsequence of arguments.
In[4]:=
Click for copyable input
Out[4]=
Attributes[f]give the attributes of f
Attributes[f]={attr1,attr2,...}set the attributes of f
Attributes[f]={}set f to have no attributes
SetAttributes[f,attr]add attr to the attributes of f
ClearAttributes[f,attr]remove attr from the attributes of f

Manipulating attributes of symbols.

This shows the attributes assigned to .
In[5]:=
Click for copyable input
Out[5]=
This removes the attributes assigned to .
In[6]:=
Click for copyable input
Out[6]=
Orderlessorderless, commutative function (arguments are sorted into standard order)
Flatflat, associative function (arguments are "flattened out")
OneIdentity, etc. are equivalent to a for pattern matching
Listablef is automatically "threaded" over lists that appear as arguments (e.g., becomes )
Constantall derivatives of f are zero
NumericFunctionf is assumed to have a numerical value when its arguments are numeric quantities
Protectedvalues of f cannot be changed
Lockedattributes of f cannot be changed
ReadProtectedvalues of f cannot be read
HoldFirstthe first argument of f is not evaluated
HoldRestall but the first argument of f are not evaluated
HoldAllnone of the arguments of f are evaluated
HoldAllCompletethe arguments of f are treated as completely inert
NHoldFirstthe first argument of f is not affected by N
NHoldRestall but the first argument of f are not affected by N
NHoldAllnone of the arguments of f are affected by N
SequenceHoldSequence objects appearing in the arguments of f are not flattened out
Temporaryf is a local variable, removed when no longer used
StubNeeds is automatically called if f is ever explicitly input

The complete list of attributes for symbols in Mathematica.

Here are the attributes for the built-in function Plus.
In[7]:=
Click for copyable input
Out[7]=

An important attribute assigned to built-in mathematical functions in Mathematica is the attribute Listable. This attribute specifies that a function should automatically be distributed or "threaded" over lists that appear as its arguments. This means that the function effectively gets applied separately to each element in any lists that appear as its arguments.

The built-in Log function is Listable.
In[8]:=
Click for copyable input
Out[8]=
This defines the function to be listable.
In[9]:=
Click for copyable input
Now is automatically threaded over lists that appear as its arguments.
In[10]:=
Click for copyable input
Out[10]=

Many of the attributes you can assign to functions in Mathematica directly affect the evaluation of those functions. Some attributes, however, affect only other aspects of the treatment of functions. For example, the attribute OneIdentity affects only pattern matching, as discussed in "Flat and Orderless Functions". Similarly, the attribute Constant is only relevant in differentiation, and operations that rely on differentiation.

The Protected attribute affects assignments. Mathematica does not allow you to make any definition associated with a symbol that carries this attribute. The functions Protect and Unprotect discussed in "Modifying Built-in Functions" can be used as alternatives to SetAttributes and ClearAttributes to set and clear this attribute. As discussed in "Modifying Built-in Functions", most built-in Mathematica objects are initially protected so that you do not make definitions for them by mistake.

Here is a definition for the function .
In[11]:=
Click for copyable input
Out[11]=
This sets the Protected attribute for .
In[12]:=
Click for copyable input
Out[12]=
Now you cannot modify the definition of .
In[13]:=
Click for copyable input
Out[13]=

You can usually see the definitions you have made for a particular symbol by typing ?f, or by using a variety of built-in Mathematica functions. However, if you set the attribute ReadProtected, Mathematica will not allow you to look at the definition of a particular symbol. It will nevertheless continue to use the definitions in performing evaluation.

Although you cannot modify it, you can still look at the definition of .
This sets the ReadProtected attribute for .
In[15]:=
Click for copyable input
Now you can no longer read the definition of .

Functions like SetAttributes and ClearAttributes usually allow you to modify the attributes of a symbol in any way. However, if you once set the Locked attribute on a symbol, then Mathematica will not allow you to modify the attributes of that symbol for the remainder of your Mathematica session. Using the Locked attribute in addition to Protected or ReadProtected, you can arrange for it to be impossible for users to modify or read definitions.

Clear[f]remove values for f, but not attributes
ClearAll[f]remove both values and attributes of f

Clearing values and attributes.

This clears values and attributes of which was given attribute Listable above.
In[17]:=
Click for copyable input
Now is no longer listable.
In[18]:=
Click for copyable input
Out[18]=

By defining attributes for a function you specify properties that Mathematica should assume whenever that function appears. Often, however, you want to assume the properties only in a particular instance. In such cases, you will be better off not to use attributes, but instead to call a particular function to implement the transformation associated with the attributes.

By explicitly calling Thread, you can implement the transformation that would be done automatically if were listable.
In[19]:=
Click for copyable input
Out[19]=
OrderlessSort[f[args]]
FlatFlatten[f[args]]
ListableThread[f[args]]
ConstantDt[expr,Constants->f]

Functions that perform transformations associated with some attributes.

Attributes in Mathematica can only be permanently defined for single symbols. However, Mathematica also allows you to set up pure functions which behave as if they carry attributes.

Function[vars,body,{attr1,...}]a pure function with attributes , ...

Pure functions with attributes.

This pure function applies to the whole list.
In[20]:=
Click for copyable input
Out[20]=
By adding the attribute Listable, the function gets distributed over the elements of the list before applying .
In[21]:=
Click for copyable input
Out[21]=
New to Mathematica? Find your learning path »
Have a question? Ask support »