PositionedRewriter

Value Members

1. final def !=(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. object Duplicator

   

   General product duplication functionality.

   General product duplication functionality. This object is a function that returns a product that applies the same constructor as the product t, but with the given children instead of t's children. The function fails if a constructor cannot be found, there are the wrong number of new children, or if one of the new children is not of the appropriate type.

   Definition Classes

   RewriterCore

5. object Term

   

   Generic term deconstruction.

   Generic term deconstruction.

   Definition Classes

   RewriterCore

6. def all(name: String, s: ⇒ Strategy): Strategy

   

   As for the version without the name argument but specifies the name for the constructed strategy.

   As for the version without the name argument but specifies the name for the constructed strategy.

   Definition Classes

   RewriterCore

7. macro def all(s: Strategy): Strategy

   

   Traversal to all children.

   Traversal to all children. Construct a strategy that applies s to all term children of the subject term. If s succeeds on all of the children, then succeed, forming a new term from the constructor of the original term and the result of s for each child. If s fails on any child, fail. If there are no children, succeed. If s succeeds on all children producing the same terms (by eq for references and by == for other values), then the overall strategy returns the subject term. This operation works on finite Rewritable, Product, Map and Traversable values, checked for in that order. Children of a Rewritable (resp. Product, collection) value are processed in the order returned by the value's deconstruct (resp. productElement, foreach) method. s is evaluated at most once.

   Definition Classes

   RewriterCore

8. def allMap[CC[V, W] <: Map[V, W]](s: Strategy, t: CC[Any, Any])(implicit cbf: CanBuildFrom[CC[Any, Any], (Any, Any), CC[Any, Any]]): Option[CC[Any, Any]]

   

   Implementation of all for Map values.

   Implementation of all for Map values.

   Definition Classes

   RewriterCore

9. def allProduct(s: Strategy, p: Product): Option[Any]

   

   Implementation of all for Product values.

   Implementation of all for Product values.

   Definition Classes

   RewriterCore

10. def allRewritable(s: Strategy, r: Rewritable): Option[Any]

    

    Implementation of all for Rewritable values.

    Implementation of all for Rewritable values.

    Definition Classes

    RewriterCore

11. def allTraversable[CC[U] <: Traversable[U]](s: Strategy, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

    

    Implementation of all for Traversable values.

    Implementation of all for Traversable values.

    Definition Classes

    RewriterCore

12. def allbu(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.allbu

13. macro def allbu(s: Strategy): Strategy

    

    Construct a strategy that applies s in a bottom-up fashion to all subterms at each level, stopping at a frontier where s succeeds.

    Construct a strategy that applies s in a bottom-up fashion to all subterms at each level, stopping at a frontier where s succeeds.

    Definition Classes

    RewriterCore

14. def alldownup2(name: String, s1: Strategy, s2: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.alldownup2

15. macro def alldownup2(s1: Strategy, s2: Strategy): Strategy

    

    Construct a strategy that applies s1 in a top-down, prefix fashion stopping at a frontier where s1 succeeds.

    Construct a strategy that applies s1 in a top-down, prefix fashion stopping at a frontier where s1 succeeds. s2 is applied in a bottom-up, postfix fashion to the result.

    Definition Classes

    RewriterCore

16. def alltd(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.alltd

17. macro def alltd(s: Strategy): Strategy

    

    Construct a strategy that applies s in a top-down fashion, stopping at a frontier where s succeeds.

    Construct a strategy that applies s in a top-down fashion, stopping at a frontier where s succeeds.

    Definition Classes

    RewriterCore

18. def alltdfold(name: String, s1: Strategy, s2: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.alltdfold

19. macro def alltdfold(s1: Strategy, s2: Strategy): Strategy

    

    Construct a strategy that applies s1 in a top-down, prefix fashion stopping at a frontier where s1 succeeds.

    Construct a strategy that applies s1 in a top-down, prefix fashion stopping at a frontier where s1 succeeds. s2 is applied in a bottom-up, postfix fashion to the results of the recursive calls.

    Definition Classes

    RewriterCore

20. def and(name: String, s1: Strategy, s2: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.and

21. macro def and(s1: Strategy, s2: Strategy): Strategy

    

    and(s1, s2) applies s1 and s2 to the subject term and succeeds if both succeed.

    and(s1, s2) applies s1 and s2 to the subject term and succeeds if both succeed. s2 will always be applied, i.e., and is not a short-circuit operator

    Definition Classes

    RewriterCore

22. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

23. def attempt(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.attempt

24. macro def attempt(s: Strategy): Strategy

    

    Construct a strategy that applies s, yielding the result of s if it succeeds, otherwise leave the original subject term unchanged.

    Construct a strategy that applies s, yielding the result of s if it succeeds, otherwise leave the original subject term unchanged. In Stratego library this strategy is called try.

    Definition Classes

    RewriterCore

25. def bottomup(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.bottomup

26. macro def bottomup(s: Strategy): Strategy

    

    Construct a strategy that applies s in a bottom-up, postfix fashion to the subject term.

    Construct a strategy that applies s in a bottom-up, postfix fashion to the subject term.

    Definition Classes

    RewriterCore

27. def bottomupS(name: String, s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.bottomupS

28. macro def bottomupS(s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

    

    Construct a strategy that applies s in a bottom-up, postfix fashion to the subject term but stops when the strategy produced by stop succeeds.

    Construct a strategy that applies s in a bottom-up, postfix fashion to the subject term but stops when the strategy produced by stop succeeds. stop is given the whole strategy itself as its argument.

    Definition Classes

    RewriterCore

29. def breadthfirst(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.breadthfirst

30. macro def breadthfirst(s: Strategy): Strategy

    

    Construct a strategy that applies s in breadth first order.

    Construct a strategy that applies s in breadth first order. This strategy does not apply s to the root of the subject term.

    It is called breadthfirst to follow Stratego's library, but is not really conducting a breadth-first traversal since all of the descendants of the first child of a term are visited before any of the descendants of the second child of a term.

    Definition Classes

    RewriterCore

31. def build(name: String, t: ⇒ Any): Strategy

    

    As for the version without the name argument but specifies the name for the constructed strategy.

    As for the version without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    RewriterCore

32. macro def build(t: Any): Strategy

    

    Construct a strategy that always succeeds, changing the subject term to the given term t.

    Construct a strategy that always succeeds, changing the subject term to the given term t. The term t is evaluated at most once.

    Definition Classes

    RewriterCore

33. def child(name: String, i: Int, s: ⇒ Strategy): Strategy

    

    As for the version without the name argument but specifies the name for the constructed strategy.

    As for the version without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    RewriterCore

34. macro def child(i: Int, s: Strategy): Strategy

    

    Traversal to a single child.

    Traversal to a single child. Construct a strategy that applies s to the ith child of the subject term (counting from one). If s succeeds on the ith child producing t, then succeed, forming a new term that is the same as the original term except that the ith child is now t. If s fails on the ith child or the subject term does not have an ith child, then fail. child(i, s) is equivalent to Stratego's i(s) operator. If s succeeds on the ith child producing the same term (by eq for references and by == for other values), then the overall strategy returns the subject term. This operation works for instances of Product or finite Seq values. s is evaluated at most once.

    Definition Classes

    RewriterCore

35. def childProduct(s: Strategy, i: Int, p: Product): Option[Any]

    

    Implementation of child for Product values.

    Implementation of child for Product values.

    Definition Classes

    RewriterCore

36. def childSeq[CC[U] <: Seq[U]](s: Strategy, i: Int, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

    

    Implementation of child for Seq values.

    Implementation of child for Seq values.

    Definition Classes

    RewriterCore

37. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

38. macro def collect[CC[X] <: Traversable[X], U](f: ==>[Any, U])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

    

    Collect query results in a traversable collection.

    Collect query results in a traversable collection. Run the function f as a top-down left-to-right query on the subject term. Each application of f returns a single value. All of these values are accumulated in the collection.

    Definition Classes

    RewriterCore

39. def collectWithName[CC[X] <: Traversable[X], U](name: String, f: ==>[Any, U])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

    

    As for collect in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for collect in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.collect

40. macro def collectall[CC[X] <: Traversable[X], U](f: ==>[Any, CC[U]])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

    

    Collect query results in a traversable collection.

    Collect query results in a traversable collection. Run the function f as a top-down left-to-right query on the subject term. Each application of f returns a collection of values. All of these values are accumulated in the collection.

    Definition Classes

    RewriterCore

41. def collectallWithName[CC[X] <: Traversable[X], U](name: String, f: ==>[Any, CC[U]])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

    

    As for collectall in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for collectall in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.collectall

42. def collectl[U](f: ==>[Any, U]): (Any) ⇒ List[U]

    

    Collect query results in a list.

    Collect query results in a list. Run the function f as a top-down left-to-right query on the subject term. Accumulate the values produced by the function in a list and return the final value of the list.

    Definition Classes

    Rewriter

43. def collects[U](f: ==>[Any, U]): (Any) ⇒ Set[U]

    

    Collect query results in a set.

    Collect query results in a set. Run the function f as a top-down left-to-right query on the subject term. Accumulate the values produced by the function in a set and return the final value of the set.

    Definition Classes

    Rewriter

44. def congruence(name: String, ss: Strategy*): Strategy

    

    As for the version without the name argument but specifies the name for the constructed strategy.

    As for the version without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    RewriterCore

45. macro def congruence(ss: Strategy*): Strategy

    

    Make a strategy that applies the elements of ss pairwise to the children of the subject term, returning a new term if all of the strategies succeed, otherwise failing.

    Make a strategy that applies the elements of ss pairwise to the children of the subject term, returning a new term if all of the strategies succeed, otherwise failing. The constructor of the new term is the same as that of the original term and the children are the results of the strategies. If the length of ss is not the same as the number of children, then congruence(ss) fails. If the argument strategies succeed on children producing the same terms (by eq for references and by == for other values), then the overall strategy returns the subject term. This operation works on instances of Product values.

    Definition Classes

    RewriterCore

46. def congruenceProduct(p: Product, ss: Strategy*): Option[Any]

    

    Implementation of congruence for Product values.

    Implementation of congruence for Product values.

    Definition Classes

    RewriterCore

47. def copy[T <: Product](t: T): T

    

    Copy a product node by creating a new node of the same class type using the same children.

    Copy a product node by creating a new node of the same class type using the same children.

    Definition Classes

    RewriterCore

48. def count(name: String, f: ==>[Any, Int]): (Any) ⇒ Int

    

    Count function results.

    Count function results. Run the function f as a top-down query on the subject term. Sum the integer values returned by f from all applications.

    Definition Classes

    Rewriter

49. macro def count(f: ==>[Any, Int]): (Any) ⇒ Int

    

    Count function results.

    Count function results. Run the function f as a top-down query on the subject term. Sum the integer values returned by f from all applications.

    Definition Classes

    RewriterCore

50. def debug(name: String, msg: String, emitter: Emitter): Strategy

    

    As for the version without the name argument but specifies the name for the constructed strategy.

    As for the version without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    RewriterCore

51. macro def debug(msg: String, emitter: Emitter = new OutputEmitter): Strategy

    

    A strategy that always succeeds with the subject term unchanged (i.e., this is the identity strategy) with the side-effect that the subject term is printed to the given emitter, prefixed by the string s.

    A strategy that always succeeds with the subject term unchanged (i.e., this is the identity strategy) with the side-effect that the subject term is printed to the given emitter, prefixed by the string s. The emitter defaults to one that writes to standard output.

    Definition Classes

    RewriterCore

52. def dispatch(name: String, s: Strategy): Strategy

    

    Produce a strategy named n that first runs the strategy s on the current term.

    Produce a strategy named n that first runs the strategy s on the current term. If s fails, then fail. Otherwise, pass the original and new terms to the rewriting method and succeed with the term that it returns.

    Definition Classes

    CallbackRewriter

53. def doloop(name: String, s: Strategy, r: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.doloop

54. macro def doloop(s: Strategy, r: Strategy): Strategy

    

    Construct a strategy that applies s at least once and then repeats s while r succeeds.

    Construct a strategy that applies s at least once and then repeats s while r succeeds. This operator is called do-while in the Stratego library.

    Definition Classes

    RewriterCore

55. def dontstop(s: ⇒ Strategy): Strategy

    

    A unit for topdownS, bottomupS and downupS.

    A unit for topdownS, bottomupS and downupS. For example, topdown(s) is equivalent to topdownS(s, dontstop).

    Definition Classes

    Rewriter

56. def downup(name: String, s1: Strategy, s2: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.downup

57. def downup(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.downup

58. macro def downup(s1: Strategy, s2: Strategy): Strategy

    

    Construct a strategy that applies s1 in a top-down, prefix fashion and s2 in a bottom-up, postfix fashion to the subject term.

    Construct a strategy that applies s1 in a top-down, prefix fashion and s2 in a bottom-up, postfix fashion to the subject term.

    Definition Classes

    RewriterCore

59. macro def downup(s: Strategy): Strategy

    

    Construct a strategy that applies s in a combined top-down and bottom-up fashion (i.e., both prefix and postfix) to the subject term.

    Construct a strategy that applies s in a combined top-down and bottom-up fashion (i.e., both prefix and postfix) to the subject term.

    Definition Classes

    RewriterCore

60. def downupS(name: String, s1: Strategy, s2: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.downupS

61. def downupS(name: String, s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.downupS

62. macro def downupS(s1: Strategy, s2: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

    

    Construct a strategy that applies s1 in a top-down, prefix fashion and s2 in a bottom-up, postfix fashion to the subject term but stops when the strategy produced by stop succeeds.

    Construct a strategy that applies s1 in a top-down, prefix fashion and s2 in a bottom-up, postfix fashion to the subject term but stops when the strategy produced by stop succeeds. stop is given the whole strategy itself as its argument.

    Definition Classes

    RewriterCore

63. macro def downupS(s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

    

    Construct a strategy that applies s in a combined top-down and bottom-up fashion (i.e., both prefix and postfix) to the subject but stops when the strategy produced by stop succeeds.

    Construct a strategy that applies s in a combined top-down and bottom-up fashion (i.e., both prefix and postfix) to the subject but stops when the strategy produced by stop succeeds. stop is given the whole strategy itself as its argument.

    Definition Classes

    RewriterCore

64. def dup[T <: Product](t: T, children: Array[AnyRef]): T

    

    Product duplication with callback notification.

    Product duplication with callback notification.

    Definition Classes

    CallbackRewriter → RewriterCore

65. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

66. val eq: Strategy

    

    A strategy that tests whether the two sub-terms of a pair of terms are equal.

    A strategy that tests whether the two sub-terms of a pair of terms are equal.

    Definition Classes

    Rewriter

67. val equal: Strategy

    

    Construct a strategy that tests whether the two sub-terms of a pair of terms are equal.

    Construct a strategy that tests whether the two sub-terms of a pair of terms are equal. Synonym for eq.

    Definition Classes

    Rewriter

68. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

69. def everything[T](name: String, v: T)(f: (T, T) ⇒ T)(g: ==>[Any, T])(t: Any): T

    

    Apply the function at every term in t in a top-down, left-to-right order.

    Apply the function at every term in t in a top-down, left-to-right order. Collect the resulting T values by accumulating them using f with initial left value v. Return the final value of the accumulation.

    Definition Classes

    Rewriter

70. macro def everything[T](v: T)(f: (T, T) ⇒ T)(g: ==>[Any, T])(t: Any): T

    

    Apply the function at every term in t in a top-down, left-to-right order.

    Apply the function at every term in t in a top-down, left-to-right order. Collect the resulting T values by accumulating them using f with initial left value v. Return the final value of the accumulation.

    Definition Classes

    RewriterCore

71. def everywhere(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.everywhere

72. macro def everywhere(s: Strategy): Strategy

    

    Same as everywheretd.

    Same as everywheretd.

    Definition Classes

    RewriterCore

73. def everywherebu(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.everywherebu

74. macro def everywherebu(s: Strategy): Strategy

    

    Construct a strategy that applies s at all terms in a bottom-up fashion regardless of failure.

    Construct a strategy that applies s at all terms in a bottom-up fashion regardless of failure. Terms for which the strategy fails are left unchanged.

    Definition Classes

    RewriterCore

75. def everywheretd(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.everywheretd

76. macro def everywheretd(s: Strategy): Strategy

    

    Construct a strategy that applies s at all terms in a top-down fashion regardless of failure.

    Construct a strategy that applies s at all terms in a top-down fashion regardless of failure. Terms for which the strategy fails are left unchanged.

    Definition Classes

    RewriterCore

77. val fail: Strategy

    

    A strategy that always fails.

    A strategy that always fails.

    Definition Classes

    RewriterCore

78. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

79. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

80. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

81. val id: Strategy

    

    A strategy that always succeeds.

    A strategy that always succeeds.

    Definition Classes

    RewriterCore

82. def innermost(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.innermost

83. macro def innermost(s: Strategy): Strategy

    

    Construct a strategy that applies s repeatedly to the innermost (i.e., lowest and left-most) (sub-)term to which it applies.

    Construct a strategy that applies s repeatedly to the innermost (i.e., lowest and left-most) (sub-)term to which it applies. Stop with the subject term if s doesn't apply anywhere.

    Definition Classes

    RewriterCore

84. def innermost2(name: String, s: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.innermost2

85. macro def innermost2(s: Strategy): Strategy

    

    An alternative version of innermost.

    An alternative version of innermost.

    Definition Classes

    RewriterCore

86. def ior(name: String, s1: Strategy, s2: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.ior

87. macro def ior(s1: Strategy, s2: Strategy): Strategy

    

    ior(s1, s2) implements inclusive OR, that is, the inclusive choice of s1 and s2.

    ior(s1, s2) implements inclusive OR, that is, the inclusive choice of s1 and s2. It first tries s1. If that fails it applies s2 (just like s1 <+ s2). However, when s1 succeeds it also tries to apply s2.

    Definition Classes

    RewriterCore

88. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

89. val isinnernode: Strategy

    

    Construct a strategy that succeeds if the current term has at least one direct subterm.

    Construct a strategy that succeeds if the current term has at least one direct subterm.

    Definition Classes

    Rewriter

90. val isleaf: Strategy

    

    Construct a strategy that succeeds if the current term has no direct subterms.

    Construct a strategy that succeeds if the current term has no direct subterms.

    Definition Classes

    Rewriter

91. val ispropersubterm: Strategy

    

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a sub-term of y but is not equal to y.

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a sub-term of y but is not equal to y.

    Definition Classes

    Rewriter

92. val ispropersuperterm: Strategy

    

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a super-term of y but is not equal to y.

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a super-term of y but is not equal to y.

    Definition Classes

    Rewriter

93. val issubterm: Strategy

    

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a sub-term of y.

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a sub-term of y.

    Definition Classes

    Rewriter

94. val issuperterm: Strategy

    

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a superterm of y.

    Construct a strategy that succeeds when applied to a pair (x,y) if x is a superterm of y.

    Definition Classes

    Rewriter

95. def lastly(name: String, s: Strategy, f: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.lastly

96. macro def lastly(s: Strategy, f: Strategy): Strategy

    

    Applies s followed by f whether s failed or not.

    Applies s followed by f whether s failed or not. This operator is called finally in the Stratego library.

    Definition Classes

    RewriterCore

97. def leaves(name: String, s: Strategy, isleaf: Strategy, skip: (Strategy) ⇒ Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.leaves

98. def leaves(name: String, s: Strategy, isleaf: Strategy): Strategy

    

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

    Definition Classes

    Rewriter

    See also

    RewriterCore.leaves

99. macro def leaves(s: Strategy, isleaf: Strategy, skip: (Strategy) ⇒ Strategy): Strategy

    

    Construct a strategy that applies to all of the leaves of the subject term, using isleaf as the leaf predicate, skipping subterms for which skip when applied to the result succeeds.

    Construct a strategy that applies to all of the leaves of the subject term, using isleaf as the leaf predicate, skipping subterms for which skip when applied to the result succeeds.

    Definition Classes

    RewriterCore

100. macro def leaves(s: Strategy, isleaf: Strategy): Strategy

     

     Construct a strategy that applies to all of the leaves of the subject term, using isleaf as the leaf predicate.

     Construct a strategy that applies to all of the leaves of the subject term, using isleaf as the leaf predicate.

     Definition Classes

     RewriterCore

101. def log(name: String, s: ⇒ Strategy, msg: String, emitter: Emitter): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

102. macro def log(s: Strategy, msg: String, emitter: Emitter): Strategy

     

     Create a logging strategy based on a strategy s.

     Create a logging strategy based on a strategy s. The returned strategy succeeds or fails exactly as s does, but also prints the provided message, the subject term, the success or failure status, and on success, the result term, to the provided emitter. s is evaluated at most once.

     Definition Classes

     RewriterCore

103. def logfail[T](name: String, s: ⇒ Strategy, msg: String, emitter: Emitter): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

104. macro def logfail[T](s: Strategy, msg: String, emitter: Emitter): Strategy

     

     Create a logging strategy based on a strategy s.

     Create a logging strategy based on a strategy s. The returned strategy succeeds or fails exactly as s does, but if s fails, also prints the provided message and the subject term to the provided emitter. s is evaluated at most once.

     Definition Classes

     RewriterCore

105. def loop(name: String, c: Strategy, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.loop

106. macro def loop(r: Strategy, s: Strategy): Strategy

     

     Construct a strategy that while r succeeds applies s.

     Construct a strategy that while r succeeds applies s. This operator is called while in the Stratego library.

     Definition Classes

     RewriterCore

107. def loopiter(name: String, s: (Int) ⇒ Strategy, low: Int, high: Int): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.loopiter

108. def loopiter(name: String, i: Strategy, r: Strategy, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.loopiter

109. macro def loopiter(s: (Int) ⇒ Strategy, low: Int, high: Int): Strategy

     

     Construct a strategy that applies s(i) for each integer i from low to high (inclusive).

     Construct a strategy that applies s(i) for each integer i from low to high (inclusive). This operator is called for in the Stratego library.

     Definition Classes

     RewriterCore

110. macro def loopiter(i: Strategy, r: Strategy, s: Strategy): Strategy

     

     Construct a strategy that repeats application of s while r fails, after initialization with i.

     Construct a strategy that repeats application of s while r fails, after initialization with i. This operator is called for in the Stratego library.

     Definition Classes

     RewriterCore

111. def loopnot(name: String, r: Strategy, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.loopnot

112. macro def loopnot(r: Strategy, s: Strategy): Strategy

     

     Construct a strategy that while r does not succeed applies s.

     Construct a strategy that while r does not succeed applies s. This operator is called while-not in the Stratego library.

     Definition Classes

     RewriterCore

113. def makechild(c: Any): AnyRef

     

     Make an arbitrary value c into a term child, checking that it worked properly.

     Make an arbitrary value c into a term child, checking that it worked properly. Object references will be returned unchanged; other values will be boxed.

     Attributes

     protected

     Definition Classes

     RewriterCore

114. def manybu(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.manybu

115. macro def manybu(s: Strategy): Strategy

     

     Construct a strategy that applies s as many times as possible, but at least once, in bottom up order.

     Construct a strategy that applies s as many times as possible, but at least once, in bottom up order.

     Definition Classes

     RewriterCore

116. def manytd(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.manytd

117. macro def manytd(s: Strategy): Strategy

     

     Construct a strategy that applies s as many times as possible, but at least once, in top down order.

     Construct a strategy that applies s as many times as possible, but at least once, in top down order.

     Definition Classes

     RewriterCore

118. def map(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.map

119. macro def map(s: Strategy): Strategy

     

     Construct a strategy that applies s to each element of a finite sequence (type Seq) returning a new sequence of the results if all of the applications succeed, otherwise fail.

     Construct a strategy that applies s to each element of a finite sequence (type Seq) returning a new sequence of the results if all of the applications succeed, otherwise fail. If all of the applications succeed without change, return the input sequence.

     Definition Classes

     RewriterCore

120. def memo(name: String, s: ⇒ Strategy): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

121. macro def memo(s: Strategy): Strategy

     

     Return a strategy that behaves as s does, but memoises its arguments and results.

     Return a strategy that behaves as s does, but memoises its arguments and results. In other words, if memo(s) is called on a term t twice, the second time will return the same result as the first, without having to invoke s. For best results, it is important that s should have no side effects. s is evaluated at most once.

     Definition Classes

     RewriterCore

122. def mkStrategy(name: String, f: (Any) ⇒ Option[Any]): Strategy

     

     Make a strategy with the given name and body f.

     Make a strategy with the given name and body f. By default, make a basic strategy.

     Definition Classes

     RewriterCore

123. final def ne(arg0: AnyRef): Boolean

     

     Definition Classes

     AnyRef

124. def not(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.not

125. macro def not(s: Strategy): Strategy

     

     Construct a strategy that applies s, then fails if s succeeded or, if s failed, succeeds with the subject term unchanged, I.e., it tests if s applies, but has no effect on the subject term.

     Construct a strategy that applies s, then fails if s succeeded or, if s failed, succeeds with the subject term unchanged, I.e., it tests if s applies, but has no effect on the subject term.

     Definition Classes

     RewriterCore

126. final def notify(): Unit

     

     Definition Classes

     AnyRef

127. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

128. def oncebu(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.oncebu

129. macro def oncebu(s: Strategy): Strategy

     

     Construct a strategy that applies s in a bottom-up fashion to one subterm at each level, stopping as soon as it succeeds once (at any level).

     Construct a strategy that applies s in a bottom-up fashion to one subterm at each level, stopping as soon as it succeeds once (at any level).

     Definition Classes

     RewriterCore

130. def oncetd(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.oncetd

131. macro def oncetd(s: Strategy): Strategy

     

     Construct a strategy that applies s in a top-down fashion to one subterm at each level, stopping as soon as it succeeds once (at any level).

     Construct a strategy that applies s in a top-down fashion to one subterm at each level, stopping as soon as it succeeds once (at any level).

     Definition Classes

     RewriterCore

132. def one(name: String, s: ⇒ Strategy): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

133. macro def one(s: Strategy): Strategy

     

     Traversal to one child.

     Traversal to one child. Construct a strategy that applies s to the term children of the subject term. Assume that c is the first child on which s succeeds. Then stop applying s to the children and succeed, forming a new term from the constructor of the original term and the original children, except that c is replaced by the result of applying s to c. In the event that the strategy fails on all children, then fail. If there are no children, fail. If s succeeds on the one child producing the same term (by eq for references and by == for other values), then the overall strategy returns the subject term. This operation works on instances of finite Rewritable, Product, Map and Traversable values, checked for in that order. Children of a Rewritable (resp. Product, collection) value are processed in the order returned by the value's deconstruct (resp. productElement, foreach) method. s is evaluated at most once.

     Definition Classes

     RewriterCore

134. def oneMap[CC[V, W] <: Map[V, W]](s: Strategy, t: CC[Any, Any])(implicit cbf: CanBuildFrom[CC[Any, Any], (Any, Any), CC[Any, Any]]): Option[CC[Any, Any]]

     

     Implementation of one for Map values.

     Implementation of one for Map values.

     Definition Classes

     RewriterCore

135. def oneProduct(s: Strategy, p: Product): Option[Any]

     

     Implementation of one for Product values.

     Implementation of one for Product values.

     Definition Classes

     RewriterCore

136. def oneRewritable(s: Strategy, r: Rewritable): Option[Any]

     

     Implementation of one for Rewritable values.

     Implementation of one for Rewritable values.

     Definition Classes

     RewriterCore

137. def oneTraversable[CC[U] <: Traversable[U]](s: Strategy, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

     

     Implementation of one for Traversable values.

     Implementation of one for Traversable values.

     Definition Classes

     RewriterCore

138. def option(name: String, o: ⇒ Option[Any]): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

139. macro def option(o: Option[Any]): Strategy

     

     Construct a strategy from an option value o.

     Construct a strategy from an option value o. The strategy succeeds or fails depending on whether o is a Some or None, respectively. If o is a Some, then the subject term is changed to the term that is wrapped by the Some. o is evaluated at most once.

     Definition Classes

     RewriterCore

140. def or(name: String, s1: Strategy, s2: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.or

141. macro def or(s1: Strategy, s2: Strategy): Strategy

     

     or(s1, s2) is similar to ior(s1, s2), but the application of the strategies is only tested.

     or(s1, s2) is similar to ior(s1, s2), but the application of the strategies is only tested.

     Definition Classes

     RewriterCore

142. def outermost(name: String, s: Strategy): Strategy

     

     Definition Classes

     Rewriter

143. macro def outermost(s: Strategy): Strategy

     

     Construct a strategy that applies s repeatedly in a top-down fashion stopping each time as soon as it succeeds once (at any level).

     Construct a strategy that applies s repeatedly in a top-down fashion stopping each time as soon as it succeeds once (at any level). The outermost fails when s fails to apply to any (sub-)term.

     Definition Classes

     RewriterCore

144. def para[T](f: (Any, Seq[T]) ⇒ T): (Any) ⇒ T

     

     Perform a paramorphism over a value.

     Perform a paramorphism over a value. This is a fold in which the recursive step may refer to the recursive component of the value and the results of folding over the children. When the function f is called, the first parameter is the value and the second is a sequence of the values that f has returned for the children. This will work on any value, but will only decompose values that are supported by the Term generic term deconstruction. This operation is similar to that used in the Uniplate library.

     Definition Classes

     RewriterCore

145. val positions: Positions

     

     Definition Classes

     PositionStore

146. macro def query[T](f: ==>[T, Unit]): Strategy

     

     Define a term query by a partial function f.

     Define a term query by a partial function f. The query always succeeds with no effect on the subject term but applies the given partial function f to the subject term. In other words, the strategy runs f for its side-effects. If the subject term is not a T or the function is not defined at the subject term, the strategy fails.

     Due to the type erasure performed on Scala programs the type test will be imprecise for some types. E.g., it is not possible to tell the difference between List[Int] and List[String].

     Definition Classes

     RewriterCore

147. def queryWithName[T](name: String, f: ==>[T, Unit]): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

148. def queryf(name: String, f: (Any) ⇒ Unit): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

149. macro def queryf(f: (Any) ⇒ Unit): Strategy

     

     Define a term query by a function f.

     Define a term query by a function f. The query always succeeds with no effect on the subject term but applies the given (possibly partial) function f to the subject term. In other words, the strategy runs f for its side-effects.

     Definition Classes

     RewriterCore

150. def reduce(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.reduce

151. macro def reduce(s: Strategy): Strategy

     

     Construct a strategy that applies s repeatedly to subterms until it fails on all of them.

     Construct a strategy that applies s repeatedly to subterms until it fails on all of them.

     Definition Classes

     RewriterCore

152. def repeat(name: String, s: Strategy, n: Int): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.repeat

153. def repeat(name: String, s: Strategy, r: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.repeat

154. def repeat(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.repeat

155. macro def repeat(s: Strategy, n: Int): Strategy

     

     Construct a strategy that applies s repeatedly exactly n times.

     Construct a strategy that applies s repeatedly exactly n times. If s fails at some point during the n applications, the entire strategy fails. The result of the strategy is that of the nth application of s.

     Definition Classes

     RewriterCore

156. macro def repeat(s: Strategy, r: Strategy): Strategy

     

     Construct a strategy that repeatedly applies s until it fails and then terminates with application of r.

     Construct a strategy that repeatedly applies s until it fails and then terminates with application of r.

     Definition Classes

     RewriterCore

157. macro def repeat(s: Strategy): Strategy

     

     Construct a strategy that applies s repeatedly until it fails.

     Construct a strategy that applies s repeatedly until it fails.

     Definition Classes

     RewriterCore

158. def repeat1(name: String, s: Strategy, r: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.repeat1

159. def repeat1(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.repeat1

160. macro def repeat1(s: Strategy, r: Strategy): Strategy

     

     Construct a strategy that repeatedly applies s (at least once) and terminates with application of c.

     Construct a strategy that repeatedly applies s (at least once) and terminates with application of c.

     Definition Classes

     RewriterCore

161. macro def repeat1(s: Strategy): Strategy

     

     Construct a strategy that repeatedly applies s (at least once).

     Construct a strategy that repeatedly applies s (at least once).

     Definition Classes

     RewriterCore

162. def repeatuntil(name: String, s: Strategy, r: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.repeatuntil

163. macro def repeatuntil(s: Strategy, r: Strategy): Strategy

     

     Construct a strategy that repeatedly applies s until c succeeds.

     Construct a strategy that repeatedly applies s until c succeeds.

     Definition Classes

     RewriterCore

164. def restore(name: String, s: Strategy, rest: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.restore

165. macro def restore(s: Strategy, rest: Strategy): Strategy

     

     Construct a strategy that applies s, then applies the restoring action rest if s fails (and then fail).

     Construct a strategy that applies s, then applies the restoring action rest if s fails (and then fail). Otherwise, let the result of s stand. Typically useful if s performs side effects that should be restored or undone when s fails.

     Definition Classes

     RewriterCore

166. def restorealways(name: String, s: Strategy, rest: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.restorealways

167. macro def restorealways(s: Strategy, rest: Strategy): Strategy

     

     Construct a strategy that applies s, then applies the restoring action rest regardless of the success or failure of s.

     Construct a strategy that applies s, then applies the restoring action rest regardless of the success or failure of s. The whole strategy preserves the success or failure of s. Typically useful if s performs side effects that should be restored always, e.g., when maintaining scope information.

     Definition Classes

     RewriterCore

168. def rewrite[T](s: Strategy)(t: T): T

     

     Rewrite a term.

     Rewrite a term. Apply the strategy s to a term returning the result term if s succeeds, otherwise return the original term.

     Definition Classes

     Rewriter

169. def rewriteTree[T <: Product, U <: T](s: Strategy)(t: Tree[T, U], shape: TreeShape = EnsureTree): Tree[T, U]

     

     Rewrite a tree.

     Rewrite a tree. Apply the strategy s to the root of a tree returning the a tree formed from the result term if s succeeds, otherwise return the original tree.

     The shape parameter specifies the tree shape that should be used when creating the new tree. The default is EnsureTree since it is likely that rewrites will result in node sharing that should be removed.

     Definition Classes

     Rewriter

170. def rewriting[T](oldTerm: T, newTerm: T): T

     

     Use the Positioned support to set the start and finish positions of the new term to be those of the old term.

     Use the Positioned support to set the start and finish positions of the new term to be those of the old term. Always return the new term.

     Definition Classes

     PositionedRewriter → CallbackRewriter

171. macro def rule[T](f: ==>[T, T]): Strategy

     

     Define a rewrite rule using a partial function f defined on the type T.

     Define a rewrite rule using a partial function f defined on the type T. If the subject term is a T and the function is defined at the subject term, then the strategy succeeds with the return value of the function applied to the subject term. Otherwise, the strategy fails.

     Due to the type erasure performed on Scala programs the type test will be imprecise for some types. E.g., it is not possible to tell the difference between List[Int] and List[String].

     Definition Classes

     RewriterCore

172. def ruleWithName[T](n: String, f: ==>[T, T]): Strategy

     

     As for rule but specifies the name for the constructed strategy.

     As for rule but specifies the name for the constructed strategy.

     Definition Classes

     CallbackRewriter → RewriterCore

173. def rulef(n: String, f: (Any) ⇒ Any): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     CallbackRewriter → RewriterCore

174. macro def rulef(f: (Any) ⇒ Any): Strategy

     

     Define a rewrite rule using a function f that returns a term.

     Define a rewrite rule using a function f that returns a term. The rule always succeeds with the return value of the function.

     Definition Classes

     RewriterCore

175. macro def rulefs[T](f: ==>[T, Strategy]): Strategy

     

     Define a rewrite rule using a function f defined on type T that returns a strategy.

     Define a rewrite rule using a function f defined on type T that returns a strategy. If the subject term is a T and the function is defined at the subject term, the rule applies the function to the subject term to get a strategy which is then applied again to the subject term. In other words, the function is only used for effects such as pattern matching. The whole thing also fails if f is not defined at the term in the first place.

     Definition Classes

     RewriterCore

176. def rulefsWithName[T](n: String, f: ==>[T, Strategy]): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     CallbackRewriter → RewriterCore

177. def some(name: String, s: ⇒ Strategy): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

178. macro def some(s: Strategy): Strategy

     

     Traversal to as many children as possible, but at least one.

     Traversal to as many children as possible, but at least one. Construct a strategy that applies s to the term children of the subject term. If s succeeds on any of the children, then succeed, forming a new term from the constructor of the original term and the result of s for each succeeding child, with other children unchanged. In the event that s fails on all children, then fail. If there are no children, fail. If s succeeds on children producing the same terms (by eq for references and by == for other values), then the overall strategy returns the subject term. This operation works on instances of finite Rewritable, Product, Map and Traversable values, checked for in that order. Children of a Rewritable (resp. Product, collection) value are processed in the order returned by the value's deconstruct (resp. productElement, foreach) method. s is evaluated at most once.

     Definition Classes

     RewriterCore

179. def someMap[CC[V, W] <: Map[V, W]](s: Strategy, t: CC[Any, Any])(implicit cbf: CanBuildFrom[CC[Any, Any], (Any, Any), CC[Any, Any]]): Option[CC[Any, Any]]

     

     Implementation of some for Map values.

     Implementation of some for Map values.

     Definition Classes

     RewriterCore

180. def someProduct(s: Strategy, p: Product): Option[Any]

     

     Implementation of some for Product values.

     Implementation of some for Product values.

     Definition Classes

     RewriterCore

181. def someRewritable(s: Strategy, r: Rewritable): Option[Any]

     

     Implementation of some for Rewritable values.

     Implementation of some for Rewritable values.

     Definition Classes

     RewriterCore

182. def someTraversable[CC[U] <: Traversable[U]](s: Strategy, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

     

     Implementation of some for Traversable values.

     Implementation of some for Traversable values.

     Definition Classes

     RewriterCore

183. def somebu(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.somebu

184. macro def somebu(s: Strategy): Strategy

     

     Construct a strategy that applies s in a bottom-up fashion to some subterms at each level, stopping as soon as it succeeds once (at any level).

     Construct a strategy that applies s in a bottom-up fashion to some subterms at each level, stopping as soon as it succeeds once (at any level).

     Definition Classes

     RewriterCore

185. def somedownup(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.somedownup

186. macro def somedownup(s: Strategy): Strategy

     

     Construct a strategy that applies s in a top-down, prefix fashion stopping at a frontier where s succeeds on some children.

     Construct a strategy that applies s in a top-down, prefix fashion stopping at a frontier where s succeeds on some children. s is then applied in a bottom-up, postfix fashion to the result.

     Definition Classes

     RewriterCore

187. def sometd(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.sometd

188. macro def sometd(s: Strategy): Strategy

     

     Construct a strategy that applies s in a top-down fashion to some subterms at each level, stopping as soon as it succeeds once (at any level).

     Construct a strategy that applies s in a top-down fashion to some subterms at each level, stopping as soon as it succeeds once (at any level).

     Definition Classes

     RewriterCore

189. macro def strategy[T](f: ==>[T, Option[T]]): Strategy

     

     Make a strategy from a partial function f defined on the type T.

     Make a strategy from a partial function f defined on the type T. If the subject term is a T and the function is defined at the subject term, then the function return value when applied to the subject term determines whether the strategy succeeds or fails. If the subject term is not a T or the function is not defined at the subject term, the strategy fails.

     Due to the type erasure performed on Scala programs the type test will be imprecise for some types. E.g., it is not possible to tell the difference between List[Int] and List[String].

     Definition Classes

     RewriterCore

190. def strategyWithName[T](n: String, f: ==>[T, Option[T]]): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     CallbackRewriter → RewriterCore

191. def strategyf(n: String, f: (Any) ⇒ Option[Any]): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     CallbackRewriter → RewriterCore

192. macro def strategyf(f: (Any) ⇒ Option[Any]): Strategy

     

     Make a strategy from a function f.

     Make a strategy from a function f. The function return value determines whether the strategy succeeds or fails.

     Definition Classes

     RewriterCore

193. final def synchronized[T0](arg0: ⇒ T0): T0

     

     Definition Classes

     AnyRef

194. macro def term[T](t: T): Strategy

     

     Construct a strategy that succeeds only if the subject term matches the given term t.

     Construct a strategy that succeeds only if the subject term matches the given term t.

     Definition Classes

     RewriterCore

195. def termWithName[T](name: String, t: T): Strategy

     

     As for the version without the name argument but specifies the name for the constructed strategy.

     As for the version without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     RewriterCore

196. def test(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.test

197. macro def test(s: Strategy): Strategy

     

     Construct a strategy that tests whether strategy s succeeds, restoring the original term on success.

     Construct a strategy that tests whether strategy s succeeds, restoring the original term on success. A synonym for where.

     Definition Classes

     RewriterCore

198. def toString(): String

     

     Definition Classes

     AnyRef → Any

199. def topdown(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.topdown

200. macro def topdown(s: Strategy): Strategy

     

     Construct a strategy that applies s in a top-down, prefix fashion to the subject term.

     Construct a strategy that applies s in a top-down, prefix fashion to the subject term.

     Definition Classes

     RewriterCore

201. def topdownS(name: String, s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.topdownS

202. macro def topdownS(s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

     

     Construct a strategy that applies s in a top-down, prefix fashion to the subject term but stops when the strategy produced by stop succeeds.

     Construct a strategy that applies s in a top-down, prefix fashion to the subject term but stops when the strategy produced by stop succeeds. stop is given the whole strategy itself as its argument.

     Definition Classes

     RewriterCore

203. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

204. final def wait(arg0: Long, arg1: Int): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

205. final def wait(arg0: Long): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

206. def where(name: String, s: Strategy): Strategy

     

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     As for the version in RewriterCore without the name argument but specifies the name for the constructed strategy.

     Definition Classes

     Rewriter

     See also

     RewriterCore.where

207. macro def where(s: Strategy): Strategy

     

     Construct a strategy that tests whether strategy s succeeds, restoring the original term on success.

     Construct a strategy that tests whether strategy s succeeds, restoring the original term on success. This is similar to Stratego's where, except that in this version any effects on bindings are not visible outside s.

     Definition Classes

     RewriterCore