anchor.diff:    (fun c -> TRY_CONV (DEPTH_QCONV c)),
     (fun c -> TRY_CONV (REDEPTH_QCONV c)),
     (fun c -> TRY_CONV (TOP_DEPTH_QCONV c)),
  -  (fun c -> TRY_CONV (TOP_SWEEP_QCONV c));;
  +  (fun c -> TRY_CONV (TOP_SWEEP_QCONV c))
   
   (* ------------------------------------------------------------------------- *)
   (* Apply at leaves of op-tree; NB any failures at leaves cause failure.      *)
  
positive.code:       [] -> cnv
      | "l"::t -> RATOR_CONV (path_conv t cnv)
      | "r"::t -> RAND_CONV (path_conv t cnv)
      | _::t -> ABS_CONV (path_conv t cnv) in
    fun s cnv -> path_conv (explode s) cnv;;
  
  (* ------------------------------------------------------------------------- *)
  (* Follow a pattern                                                          *)
  
negative.code: /// Basic equality reasoning including conversionals.
  module NHol.equal
  
  open FSharp.Compatibility.OCaml
  open lib
  open fusion
  open basics
  open nets
  open printer
  open preterm
  open parser
  
  (*
  (* ------------------------------------------------------------------------- *)
  (* Type abbreviation for conversions.                                        *)
  (* ------------------------------------------------------------------------- *)
  
  type conv = term->thm
  
  (* ------------------------------------------------------------------------- *)
  (* A bit more syntax.                                                        *)
  (* ------------------------------------------------------------------------- *)
  
  let lhand = rand << rator
  
  let lhs = fst << dest_eq
  
  let rhs = snd << dest_eq
  
  (* ------------------------------------------------------------------------- *)
  (* Similar to variant, but even avoids constants, and ignores types.         *)
  