Enable JavaScript to interact with content and submit forms on Wolfram websites. Learn how

Wolfram Language & System Documentation Center

RuleDelayed

RuleDelayed

lhs:>rhs or lhsrhs

represents a rule that transforms lhs to rhs, evaluating rhs only after the rule is used.

Details

The character  can be entered as :> or ∖[RuleDelayed].
RuleDelayed has the attribute HoldRest.
You can apply rules using Replace.
The assignment lhs:=rhs specifies that the rule lhs:>rhs should be used whenever it applies.
You can use Condition to specify when a particular rule applies.
In StandardForm, RuleDelayed is printed using .

Examples

open all close all

Basic Examples (1)

:> holds its right-hand side unevaluated:

Wolfram Language code: x :> RandomReal[]

The right-hand side is evaluated separately each time it is used:

Wolfram Language code: {x, x, x} /. x :> RandomReal[]

Applications (3)

Increment n each time x is replaced:

Wolfram Language code: n = 1;{x, x, a, b, x, x, c, d} /. x :> n++

Evaluate the StepMonitor expression separately each time it is to be used:

Wolfram Language code: FindRoot[Cos[x] == x, {x, 1}, StepMonitor :> Print[x]]

Generate a diagonal matrix with random elements:

Wolfram Language code: SparseArray[{{i_, i_} :> RandomReal[]}, {4, 4}]//MatrixForm

Properties & Relations (6)

-> evaluates when it is first entered; :> when it is used:

Wolfram Language code: {x, x, x, x} /. x -> RandomReal[]

Wolfram Language code: {x, x, x, x} /. x :> RandomReal[]

Module and With do not affect local variables of RuleDelayed:

Wolfram Language code: With[{x = 1}, a /. x_ :> x + 1]

Module effectively uses a renamed instance of y:

Wolfram Language code: {incr[x], incr[y]} /. incr[x_] :> Module[{y = 1}, x + y]

By evaluating the arguments to RuleDelayed, local scoping is avoided:

Wolfram Language code: Module[{expr = x ^ 2}, a /. RuleDelayed@@{x_, expr}]

KeyValuePattern can be used to transform a list of rules:

Wolfram Language code: Replace[{a :> 1, b :> 2, c :> 3}, KeyValuePattern[{a :> x_, c :> y_}] -> {a :> f[x], c :> g[y]}]

KeyValuePattern distinguishes between Rule and RuleDelayed:

Wolfram Language code: Replace[{a :> 1, b :> 2, c :> 3}, KeyValuePattern[{a -> x_, c -> y_}] -> {a :> f[x], c :> g[y]}]

Top