Replace by default applies rules only to complete expressions:

It does not map down to subparts:

A list of lists of rules gives a list of results:

Use Replace in operator form:

Apply a single possible replacement:

Apply the first matching rule:

Apply each rule separately:

If no rule matches, the original expression is returned:

Replace at level 1:

Replace elements of a list that yield True when a test function is applied:

Replace elements of a list that satisfy a Boolean expression:

Replace elements of a matrix with a particular head:

Replace the deepest parts of the expression, i.e. those with no subparts:

Replace at levels 1 through 3:

Replace at levels 0 through 2:

Replace at all levels:

Replace also works with RuleDelayed:

Structurally insert into a held expression:

Do not evaluate the right-hand side of the rule before doing the replacement:

Evaluate the right-hand side before replacement:

Dispatch can be used in place of a list of rules:

Association can be used in place of a list of rules:

Apply a function to all values in an Association:

Replace an Association with the key and value reversed:

Extract all rules in Association to a list:

Replace at level 1, destructuring values that are themselves associations:

Define a function f:

Normally, it will be repeatedly evaluated until a final result is reached:

Hold the input and replace it using the DownValues of f to inspect a single step of the evaluation:

Proceed one level further:

An empty list is considered to have no matching rules:

When a list of lists is used for replacement, the result is a list of the same length:

The level specification All is equivalent to {0,-1} and {0,∞}:

If a rule matches at multiple levels, Replace will transform all matching subexpressions:

See the order in which the replacements occurred:

When multiple levels are given, Replace scans the expression using a depth-first search:

Replace replaces a whole expression by default:

It also allows specific levels to be replaced:

ReplaceAll replaces any matching part:

Replace with level spec All will attempt to replace every subexpression exactly once:

ReplaceAll replaces the largest subexpressions it can and then stops:

ReplaceRepeated repeatedly applies ReplaceAll until the expression stops changing:

Replace matches parts at a particular level against a pattern:

ReplacePart rewrites subexpressions at a particular position:

ReplaceList gives a list of results using all possible matches:

Replace gives the first, canonical match:

Replace can transform a complete association:

But when it enters an association it will only replace values, not keys:

Replace matches individual expressions in a given level:

SequenceReplace matches sequences of expressions in the first level:

Replace[expr,lhsrhs] returns a transformed result if and only if MatchQ[expr,lhs] yields True:

Applying a long list of rules can be slow:

Using Dispatch can be significantly faster:

Associations can be used to specify replacement rules, but the keys are treated as Verbatim values:

Compare with the following:

The list of rules equivalent to the association is the following: