anchor.diff:                          inner <- None
                       | _ -> ()
   
  +    type private AListRenderTask(tasks : alist<IRenderTask>) as this =
  +        inherit AdaptiveObject()
  +        let reader = tasks.GetReader()
  +        do reader.AddOutput this
  +
  +        let tasks = ReferenceCountingSet()
  +
  +        let add (t : IRenderTask) =
  +            if tasks.Add t then
  +                t.AddOutput this
  +
  +        let remove (t : IRenderTask) =
  +            if tasks.Remove t then
  +                t.RemoveOutput this
  +
  +        interface IRenderTask with
  +            member x.Run(fbo) =
  +                base.EvaluateAlways(fun () ->
  +                    // TODO: EvaluateAlways should ensure that self is OutOfDate since
  +                    //       when its not we need a transaction to add outputs
  +                    this.OutOfDate <- true
  +
  +                    // adjust the dependencies
  +                    for d in reader.GetDelta() do
  +                        match d with
  +                            | Add(_,t) -> add t
  +                            | Rem(_,t) -> remove t
  +
  +                    // run all tasks
  +                    let mutable stats = FrameStatistics.Zero
  +                    for (_,t) in reader.Content do
  +                        let res = t.Run(fbo)
  +                        stats <- stats + res.Statistics
  +
  +                    // return the accumulated statistics
  +                    RenderingResult(fbo, stats)
  +                )
  +
  +            member x.Dispose() =
  +                reader.RemoveOutput this
  +                reader.Dispose()
  +
  +                for i in tasks do
  +                    i.RemoveOutput x
  +                tasks.Clear()
  +
  +
  +    let empty = new EmptyRenderTask() :> IRenderTask
  +
  +    let ofMod (m : IMod<IRenderTask>) : IRenderTask =
  +        new ModRenderTask(m) :> IRenderTask
   
       let bind (f : 'a -> IRenderTask) (m : IMod<'a>) : IRenderTask =
           new ModRenderTask(Mod.map f m) :> IRenderTask
  
positive.code:     let ofArray (s : IRenderTask[]) =
          new SequentialRenderTask(s) :> IRenderTask
  
  
negative.code: 
  module RenderTask =
      
      type private EmptyRenderTask() =
          inherit ConstantObject()
          interface IRenderTask with
              member x.Dispose() = ()
              member x.Run(fbo) = RenderingResult(fbo, FrameStatistics.Zero)
  
      type private SequentialRenderTask(tasks : IRenderTask[]) as this =
          inherit AdaptiveObject()
  
  