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