%TOC%
------------------------------------------------------------
-----+++ Description
A _contextual rule_ is a [[rewrite rule]] in which the left-hand side and right-hand side terms contain contexts of the form =x[t]=.
A typical example of a contextual rule is the following inlining rule:
Inline : Let(x, e1, e2[Var(x)]) -> Let(x, e1, e2[e1])
The idea is that an occurrence of =Var(x) in =e2= is replaced with the term =e1=.
Contextual rules are treated as syntactic sugar and translated to a normal rule, which
performs a traversal over the context subterm. The inlining rule above is translated to
the rule:
Inline :
Let(x, e1, e2) -> Let(x, e1, e2')
where e2 => e2'
The traversal strategy =oncetd= is used to find an occurrence of =Var(x)= and replace it
with =e1=. Note that in the match of =Var(x)=, the variable =x= is already bound by the
match of the left-hand =Let(x, e1, e2)= side of the rule.
-- Main.EelcoVisser - 08 Jan 2002
Note that for many applications (such as inlining) [[dynamic rules]] are often more
appropriate than contextual rules since they allow the replacement traversal and
the surrounding traversal to be merged.
-- Main.EelcoVisser - 29 Jul 2003
------------------------------------------------------------
-----+++ Issues
* traversal strategy
* multiple contexts
* conditions
* overlapping contextual rules
* backtracking
-- Main.EelcoVisser - 08 Jan 2002
------------------------------------------------------------
----+++ Contexts in Strategy
I'm trying to use context matching inside a strategy.
For example,
rule1 : MyTerm(x[AnotherTerm]) -> MyTerm(x[AnotherTerm])
will match fine. but when I try to do it in a strategy the sc compiler
complains (not a term-expression: Con ....)
strat1: ?MyTerm(x[AnotherTerm]) ; debug
So, can someone tell me how to do deep context matching inside a strategy?
I need to do this so that I can use the contents of a variable as part of
the search criteria. I can't see how to do this with a rule.
-- DAN - 29 Jul 2003
That is correct; contexts are only implemented for rules.
Here are some ways to do it:
(1) first match, then traverse
?MyTerm(x); where( x); debug
This actually corresponds to the desugaring of contextual rules. That
is, rule1 is really sugar for
rule1 : MyTerm(x) -> MyTerm(x')
where x => x'
(2) Using TermProject you can abbreviate (1) as
?MyTerm(); debug
you should note, however, that the debug will now print the subterm
of =MyTerm=. That is (2) is the same as
?MyTerm(x); x; debug
that is (1) without the where surrounding the traversal.
(3) If necessary you can of course use alternative traversals.
-- Main.EelcoVisser - 29 Jul 2003
------------------------------------------------------------
----+++ Different Implementation
A different implementation of contexual rules is possible though.
The current implementation optimizes finding and replacing the
holes in a context. It is of course possible to treat matching
and building with context separately, just as is done with normal
terms. This would mean that a context match =?MyTerm(x[t])= would
bind to =x= an object representing the subterm of =MyTerm= with
holes at the place (or places) where t was found. A build =!MyTerm(x[t'])=
would fill the holes with =t'=. The more efficient
implementation currently used might be derivable from the more
general one.
-- Main.EelcoVisser - 29 Jul 2003
------
CategoryGlossary