anchor.diff:    vec2 position;
   
     Place(this.position);
  -
     Place clone() => new Place(position);
  -  start() => target.position = 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);
  -  start() => method();
  +  
  +  void start() { 
  +    method(); 
  +  }
   }
   
   class Hide extends InstantAction {
  -
     Hide clone() => new Hide();
     Show reverse() => new Show();
  -  start() => target.visible = false;
  +  
  +  void start() {
  +    target.visible = false;
  +  }
   }
   
   class Show extends InstantAction {
  -
     Show clone() => new Show();
     Hide reverse() => new Hide();
  -  start() => target.visible = true;
  +  
  +  void start() {
  +    target.visible = true;
  +  }
   }
   
   class ToggleVisibility extends InstantAction {
  -
     ToggleVisibility clone() => new ToggleVisibility();
     ToggleVisibility reverse() => new ToggleVisibility();
  -  start() => target.visible = !target.visible;
  +  
  +  void start() {
  +    target.visible = !target.visible; 
  +  }
   }
   
   abstract class IntervalAction extends Action {
  
positive.code: }
  
  class Delay extends IntervalAction {
  
    Delay(num duration): super(duration);
    Delay clone() => new Delay(duration);
  
    start() {}
    stop() {}
    _interval(num t) {}
  }
  
  
negative.code: class Loop extends Action {
    Action action;
    bool done = false;
    Action activeAction = null;
  
    Loop(Action this.action);
    Loop clone() => new Loop(action);
    Loop reverse() => new Loop(action.reverse());
  
    void start() => _nextAction();
  
    void step(num dt) {
      activeAction.step(dt);
      if (activeAction.done) {
        _nextAction();
      }
    }
  
    void stop() {}
  
    void _nextAction() {
      if (activeAction != null) {
        activeAction.stop();
      }
      activeAction = action.clone();
  
      activeAction.target = target;
      activeAction.start();
  
      // this is useful for instant actions
      if (activeAction.done) {
        _nextAction();
      }
    }
  