anchor.diff:      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()
  
positive.code:                         inner <- None
                      | _ -> ()
  
  
      let bind (f : 'a -> IRenderTask) (m : IMod<'a>) : IRenderTask =
          new ModRenderTask(Mod.map f m) :> 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()
  
  