anchor.diff:  /// <summary>
   ///     Map of known backend parameters.
   /// </summary>
  -let rec backendParams () =
  +let rec backendParams ()
  +  : Map<string, string * (BackendParams -> BackendParams)> =
       Map.ofList
           [ ("approx",
              ("Replace all symbols in a proof with their under-approximation.\n\
  
positive.code:         match request with
          | Request.SymProof    -> phase symproof Response.SymProof
          | Request.RawSymProof -> phase (symproof >> rawproof) Response.RawSymProof
          | Request.Proof       -> phase (symproof >> proof approx) Response.Proof
          | Request.RawProof    -> phase (symproof >> proof approx >> rawproof) Response.RawProof
          | Request.Z3 rq       -> phase (symproof >> proof approx >> z3 reals rq) Response.Z3
          | Request.HSF         -> phase (filterIndefinite >> hsf) Response.HSF
          | Request.MuZ3 rq     -> phase (filterIndefinite >> muz3 reals rq) Response.MuZ3
          | Request.SymZ3 rq    -> phase (symproof >> (tuplize (proof approx >> z3 reals rq))) Response.SymZ3
          | _                   -> fail (Error.Other "Internal")
  
      //Build a phase with
  
negative.code:     >> printfn "%s"
  
  /// Prints an err result to stderr.
  let printErr (pBad : 'Error list -> Doc list) : 'Error list -> unit =
      pBad >> headed "Errors" >> print >> eprintfn "%s"
  
  /// Pretty-prints a Chessie result, given printers for the successful
  /// case and failure messages.
  let printResult (pOk : 'Ok -> Doc) (pBad : 'Error list -> Doc list)
    : Result<'Ok, 'Error> -> unit =
      either (printOk pOk pBad) (printErr pBad)
  
  /// Shorthand for the raw proof output stage.
  