calc: Selections with Rewrite Rules
11.11.9 Selections with Rewrite Rules
-------------------------------------
If a sub-formula of the current formula is selected (as by ‘j s’; 
Selecting Subformulas), the ‘a r’ (‘calc-rewrite’) command applies
only to that sub-formula. Together with a negative prefix argument, you
can use this fact to apply a rewrite to one specific part of a formula
without affecting any other parts.
The ‘j r’ (‘calc-rewrite-selection’) command allows more
sophisticated operations on selections. This command prompts for the
rules in the same way as ‘a r’, but it then applies those rules to the
whole formula in question even though a sub-formula of it has been
selected. However, the selected sub-formula will first have been
surrounded by a ‘select( )’ function call. (Calc’s evaluator does not
understand the function name ‘select’; this is only a tag used by the ‘j
r’ command.)
For example, suppose the formula on the stack is ‘2 (a + b)^2’ and
the sub-formula ‘a + b’ is selected. This formula will be rewritten to
‘2 select(a + b)^2’ and then the rewrite rules will be applied in the
usual way. The rewrite rules can include references to ‘select’ to tell
where in the pattern the selected sub-formula should appear.
If there is still exactly one ‘select( )’ function call in the
formula after rewriting is done, it indicates which part of the formula
should be selected afterwards. Otherwise, the formula will be
unselected.
You can make ‘j r’ act much like ‘a r’ by enclosing both parts of the
rewrite rule with ‘select()’. However, ‘j r’ allows you to use the
current selection in more flexible ways. Suppose you wished to make a
rule which removed the exponent from the selected term; the rule
‘select(a)^x := select(a)’ would work. In the above example, it would
rewrite ‘2 select(a + b)^2’ to ‘2 select(a + b)’. This would then be
returned to the stack as ‘2 (a + b)’ with the ‘a + b’ selected.
The ‘j r’ command uses one iteration by default, unlike ‘a r’ which
defaults to 100 iterations. A numeric prefix argument affects ‘j r’ in
the same way as ‘a r’. Nested Formulas with Rewrite Rules.
As with other selection commands, ‘j r’ operates on the stack entry
that contains the cursor. (If the cursor is on the top-of-stack ‘.’
marker, it works as if the cursor were on the formula at stack level 1.)
If you don’t specify a set of rules, the rules are taken from the top
of the stack, just as with ‘a r’. In this case, the cursor must
indicate stack entry 2 or above as the formula to be rewritten
(otherwise the same formula would be used as both the target and the
rewrite rules).
If the indicated formula has no selection, the cursor position within
the formula temporarily selects a sub-formula for the purposes of this
command. If the cursor is not on any sub-formula (e.g., it is in the
line-number area to the left of the formula), the ‘select( )’ markers
are ignored by the rewrite mechanism and the rules are allowed to apply
anywhere in the formula.
As a special feature, the normal ‘a r’ command also ignores ‘select(
)’ calls in rewrite rules. For example, if you used the above rule
‘select(a)^x := select(a)’ with ‘a r’, it would apply the rule as if it
were ‘a^x := a’. Thus, you can write general purpose rules with
‘select( )’ hints inside them so that they will “do the right thing” in
both ‘a r’ and ‘j r’, both with and without selections.
Info Catalog
calc: Multi-Phase Rewrite Rules
calc: Rewrite Rules
calc: Matching Commands