From: Andrei Alexandrescu (andrei@cs.washington.edu)
Date: Sun Nov 03 2002 - 00:37:25 PST
While talking about AOP with Jonathan, I made a realization that I thought
I'd share with you all.
In essence AOP is an AST transformer. It allows you to transform the AST of
classes and functions in well-defined ways: the compiler parses a class into
its AST, and then the so-called aspect weaver effects transformations on
certain nodes of that trees (notably function calls).
I was thinking of what relationship AOP has with parametric polymorphism,
and here's how it feels. Parametric polymorphism can be seen as an AST
transformation as well. The simplest transformation is replacing a type
parameter with an actual type name, but this activity can lead to quite
subtle transformations when you think that that type has member functions,
nested types, and so on. For example, the standard C++ vector is
parameterized not only by the contained type, but also by the allocation
strategy: vector<T, allocator>. The latter parameter defines both structure
(allocation state injected by the allocator straight in the vector object)
and functionality (the way memory is manipulated).
Now it looks like, given an AST, you can transform it in two ways:
parametric polymorphism (explicit transformation conditioned by the initial
AST including type parameters) and AOP (implicit transformations defined by
the "environment" in which the AST exists).
So now imagine aspects being of two kinds: explicit and implicit. The
explicit ones you have to pass to your class. The implicit ones constitute
the "environment" in which the AST is transformed. For example, consider a
Point class - common example in AOP docs. Now, they say the point's bounds
checking would be an aspect. That would be an implicit aspect. Cool. Now
consider point's precision - short versus int versus double etc. That would
be an explicit aspect (corresponding to a type parameter).
You'd say (made-up syntax):
implicit aspect PointChecking {
pointcut assign(Point p, int x) : call(* Point.set*(..)) etc. etc.
...
}
abstract aspect PointPrecision{
typedef BaseType;
public BaseType RoundUp(BaseType);
...
}
explicit aspect DoublePointPrecision implements PointPrecision {
typedef double BaseType;
public BaseType RoundUp(BaseType) {
...
}
...
}
class Point parameter PointPrecision {
...
}
...
Point{DoublePointPrecision} p;
As in typical parametric polymorphism, Point{P1} and Point{P2} would be
distinct types. This amenity is not provided today by AOP - AOP allows you
to customize a type's AST in many ways, but at the end of the day you still
have only *one* type to play with. AOP cannot generate new types.
By adding explicit aspects, AOP would cover tasks commonly tackled with
parametric polymorphism.
If anyone has thoughts about all that, I'd be glad to hear them... thanks!
Andrei
_______________________________________________
Cecil mailing list
Cecil@cs.washington.edu
http://majordomo.cs.washington.edu/mailman/listinfo/cecil
This archive was generated by hypermail 2.1.5 : Sun Nov 03 2002 - 00:37:48 PST