anchor.diff:          | Shader (input, output, program) ->
   
               Pipeline (
  -                fun _ ->
  -                    f input program.Draw
  +                fun context ->
  +                    context.AddAction (fun () ->
  +                        f input program.Draw
  +                    )
                       output
               )
   
  
positive.code: 
      let clear =
          Pipeline (
              fun _ ->
                  Backend.clear ()
          )
  
      let captureFrame p =
  
          let mutable renderTextureOpt = None
          Pipeline (
              fun context ->
                  let renderTexture =
                      match renderTextureOpt with
                      | None ->
                          let renderTexture = RenderTexture (1280, 720)
                          context.AddRelease renderTexture.Release
                          renderTextureOpt <- Some renderTexture
                          renderTexture
  
                      | Some renderTexture -> renderTexture                  
                  
                  match p with
                  | Pipeline f -> f context
  
                  renderTexture
          )
  
      let getShader name createInput createOutput =
          
          let mutable shaderOpt = None
          Pipeline (
              fun context ->
                  let shader =
                      match shaderOpt with
                      | None ->
                          let shaderProgram = context.ShaderProgramCache.GetOrCreateShader (name)
                          let input = createInput shaderProgram
                          let output = createOutput shaderProgram
                          let shader = Shader (input, output, shaderProgram)
                          shaderOpt <- Some shader
                          shader
  
                      | Some shader -> shader
  
                  shader
          )
  
negative.code:         pipeline {
              let! finalShader = getShader "Fullscreen" FinalInput (fun _ -> ())
  
              let! renderTexture = captureFrame 1280 720 worldPipeline
  
              do! finalShader.Run (fun input draw ->
                  input.Time.Set (getTime ())
  