anchor.diff:  
   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()
   
  
positive.code:                         inner <- None
                      | _ -> ()
  
  
      let bind (f : 'a -> IRenderTask) (m : IMod<'a>) : IRenderTask =
          new ModRenderTask(Mod.map f m) :> IRenderTask
  
negative.code:     let ofArray (s : IRenderTask[]) =
          new SequentialRenderTask(s) :> IRenderTask
  
      let ofAList (s : alist<IRenderTask>) =
          new AListRenderTask(s) :> IRenderTask
  
      let ofASet (s : aset<IRenderTask>) =
          new AListRenderTask(s |> ASet.sortWith (fun a b -> 0)) :> IRenderTask
  
  [<AutoOpen>]
  module ``RenderTask Builder`` =
  
      type RenderTaskBuilder() =
          member x.Bind(m : IMod<'a>, f : 'a -> alist<IRenderTask>) =
              alist.Bind(m, f)
  
          member x.For(s : alist<'a>, f : 'a -> alist<IRenderTask>) =
              alist.For(s,f)
  
  
          member x.Yield(t : IRenderTask) = 
              alist.Yield(t)
  
          member x.YieldFrom(l : alist<IRenderTask>) =
              alist.YieldFrom(l)
  
          member x.Yield(m : IMod<IRenderTask>) =
              m |> RenderTask.ofMod |> alist.Yield
  
          member x.Combine(l : alist<IRenderTask>, r : alist<IRenderTask>) =
              alist.Combine(l,r)
  
          member x.Delay(f : unit -> alist<IRenderTask>) = 
              alist.Delay(f)
  
          member x.Zero() =
              alist.Zero()
  
          member x.Run(l : alist<IRenderTask>) =
              RenderTask.ofAList l
  
  
      let rendertask = RenderTaskBuilder()
  