anchor.diff:                  renderTexture
           )
   
  -    let getShader name createInput createOutput =
  +    let getProgram name createInput createOutput =
           Pipeline (
               fun context ->
                   let shaderProgram = context.ProgramCache.CreateShaderProgram (name)
  
positive.code: // *****************************************
  // *****************************************
  
  type Shader<'Input, 'Output> = Shader of 'Input * 'Output * ShaderProgram
  
  [<Sealed>]
  type PipelineContext (programCache: ProgramCache) =
      
      let releases = ResizeArray<unit -> unit> ()
      let actions = ResizeArray<unit -> unit> ()
  
      member val ProgramCache = programCache
  
      member this.AddRelease release =
          releases.Add release
  
negative.code:                 shader
          )
  
      let runProgram name createInput createOutput f =
          pipeline {
              let! shader = getProgram name createInput createOutput
              return! shader.Run f
          }
  
      let runSubPipeline name =
          Pipeline (
              fun context ->
                  context.UseSubPipeline (name)
          )
  
      let runProgramWithMesh<'T, 'Input when 'Input :> MeshInput> name createInput createOutput init f =
          Pipeline (
              fun context ->
                  let program = context.ProgramCache.CreateShaderProgram (name)
                  let input : 'Input = createInput program
                  let output = createOutput program
  
                  let draw = (fun () -> program.Run RenderPass.Depth)
  
                  context.CurrentSubPipeline
                  |> Option.iter (fun subPipeline ->
  
                      subPipeline.TryGetLookup<'T> ()
                      |> Option.iter (fun lookup ->
  
                          context.AddAction (fun () ->
                              Backend.useProgram program.programId
  
                              input.Time.Set context.Time
                              input.View.Set context.View
                              input.Projection.Set context.Projection
  
                              init input
  
                              lookup
                              |> Seq.iter (fun pair ->
                                  let key = pair.Key
                                  let (texture, meshManager) = pair.Value
  
                                  input.Texture.Set texture.Buffer
  
                                  meshManager.ForEach (fun id (mesh, o) ->
                                      let o = 
                                          if o = null then Unchecked.defaultof<'T>
                                          else o :?> 'T
  
                                      input.Position.Set mesh.Position
                                      input.Uv.Set mesh.Uv
                                      input.Color.Set mesh.Color
  
                                      f o input draw
                                  )
                              )
  
                              program.Unbind ()
                              Backend.useProgram 0
                          )
                      )
                  )
  
                  output 
          )
  
  open Pipeline
  
  