anchor.diff:  
     IntervalAction(num this.duration);
   
  -  step(dt) {
  +  void step(dt) {
       ellapsedTime = min(ellapsedTime + dt, duration);
       _interval(ellapsedTime/duration); // TODO: check duration == 0
     }
   
  -  _interval(num t);
  +  void _interval(num t);
   }
   
   abstract class ChangeAttributeToAction extends IntervalAction {
  +  // TODO: Add type annotations
     var startValue;
     var deltaValue;
     var endValue;
  
positive.code:   bool get done => false;
  
    Action();
  
    Action clone();
    void start();
    void step(num dt);
    void stop();
  
    reverse() {
      throw "Reverse not available";
    }
  
    Action operator +(Action action) {
      return new ActionSequence([this, action]);
    }
  
    Action operator |(Action action) {
      return new ActionSpawn([this, action]);
    }
  }
  
  abstract class InstantAction extends Action {
  
negative.code:   vec2 position;
  
    Place(this.position);
    Place clone() => new Place(position);
    
    void start() {
      target.position = position; 
    }
  }
  
  class CallFunction extends InstantAction {
    // TODO use a typedef here
    dynamic method;
    vec2 position;
  
    CallFunction(this.method);
    CallFunction clone() => new CallFunction(method);
    
    void start() { 
      method(); 
    }
  }
  
  class Hide extends InstantAction {
    Hide clone() => new Hide();
    Show reverse() => new Show();
    
    void start() {
      target.visible = false;
    }
  }
  
  class Show extends InstantAction {
    Show clone() => new Show();
    Hide reverse() => new Hide();
    
    void start() {
      target.visible = true;
    }
  }
  
  class ToggleVisibility extends InstantAction {
    ToggleVisibility clone() => new ToggleVisibility();
    ToggleVisibility reverse() => new ToggleVisibility();
    
    void start() {
      target.visible = !target.visible; 
    }
  }
  
  abstract class IntervalAction extends Action {
  