Here is a quick outline of an idea of how the aspect-oriented programming 
paradigm could be incorporated into D. What I’d like to propose is picking only 
the most useful features of AOP while keeping D as lean as it is.
The big promise of AOP is the potential of keeping your code very clean even as 
it grows by having your orthogonal concerns kept apart. The extensions to the 
current D syntax that would be needed may not be that many:



Suppose you have this class:

class Foo
{
      int fun( int x )
      {
      }
}



Now let’s create some advice. Advice is code that is injected to handle some 
specific concern. One reason complex programs easily become cluttered is that 
they usually have many different concerns with little bits and pieces of them 
everywhere. AOP solves this by abstracting concerns into separate units instead 
of having each concern scattered all over the code. It’s a kind of modularity.


mixin template AdviceX()
{
      int fun( int x )
      scope( entry )
      {
      }
      scope( exit )
      {
      }
      scope( failure )
      {
            // undo changes here.
      }
      scope( success )( returnValue )
      {
            //  const access to return value.
      }
}


The new thing here would be the ability to append statements to the beginning 
and end of a scope. By using the excellent scope construct different advice are 
kept separate and yet well integrated with the rest of the code. Any exception 
will be dealt with properly.


Here is how you would include the mixin advice:

class Foo
{
      mixin AdviceX;
      mixin AdviceY;

      int fun( int x )
      {
            // not replaced.
      }
}


The order in which the mixin advice are specified determines their nesting 
order.


Please comment!

Reply via email to