anchor.diff:  
       interface RenderProcess2d with
   
  +        member this.Started =
  +            lock startedLock (fun () -> started)
  +
           member this.Terminated =
               lock terminatedLock (fun () -> terminated)
   
  
positive.code: 
                  // create renderer
                  let renderer = createRenderer2d window : Renderer2d
  
                  // loop until terminated
                  while not (this :> RenderProcess2d).Terminated do
  
negative.code:         abstract Terminate : unit -> unit
          end
  
  /// A non-threaded 2d render process.
  type RenderInline2d (createRenderer2d, window : nativeint) =
  
      let mutable started = false
      let mutable terminated = false
      let mutable rendererOpt = Option<Renderer2d>.None
  
      interface RenderProcess2d with
  
          member this.Started =
              started
  
          member this.Terminated =
              terminated
  
          member this.Start () =
              match rendererOpt with
              | Some _ -> raise (InvalidOperationException "Redundant Start calls.")
              | None ->
                  rendererOpt <- Some (createRenderer2d window)
                  started <- true
  
          member this.Submit eyePosition eyeSize eyeMargin messages =
              match rendererOpt with
              | Some renderer -> renderer.Render eyePosition eyeSize eyeMargin messages
              | None -> raise (InvalidOperationException "Renderer is not yet or is no longer valid.")
  
          member this.Swap () =
              match rendererOpt with
              | Some renderer -> renderer.Swap ()
              | None -> raise (InvalidOperationException "Renderer is not yet or is no longer valid.")
  
          member this.Terminate () =
              match rendererOpt with
              | Some renderer ->
                  renderer.CleanUp () |> ignore<Renderer2d>
                  rendererOpt <- None
                  terminated <- true
              | None -> raise (InvalidOperationException "Redundant Terminate calls.")
  
  /// A threaded 2d render process.
  type RenderThread2d (createRenderer2d, window : Window) =
  
      let mutable taskOpt = null
      let startedLock = obj ()
      let mutable started = false
      let terminatedLock = obj ()
      let mutable terminated = false
      let submissionLock = obj ()
  