anchor.diff:                      if compare tm' tm = 0 then 
                           return! fth
                       else 
  -                        return! SUBS [ALPHA tm' tm] fth
  -                                |> Choice.mapError (fun e -> nestedFailure e "PART_MATCH: Sanity check failure")
  +                        return!
  +                            SUBS [ALPHA tm' tm] fth
  +                            |> Choice.mapError (fun e -> nestedFailure e "PART_MATCH: Sanity check failure")
               }
       PART_MATCH, GEN_PART_MATCH
   
  
positive.code: /// Conjoin both sides of two equational theorems.
  let MK_CONJ = 
      let andtm = parse_term @"(/\)"
      fun eq1 eq2 -> MK_COMB(AP_TERM andtm eq1, eq2)
  
  /// Disjoin both sides of two equational theorems.
  let MK_DISJ = 
      let ortm = parse_term @"(\/)"
      fun eq1 eq2 -> MK_COMB(AP_TERM ortm eq1, eq2)
  
  /// Universally quantifies both sides of equational theorem.
  let MK_FORALL = 
  
negative.code:         }
          |> Choice.mapError (fun e -> nestedFailure e "MATCH_MP: Not an implication")
  
      let match_fun : term -> thm =
          PART_MATCH (Choice.map fst << dest_imp) sth
  
      fun (th : thm) ->
          choice {
          let! th' = th
          // CLEAN : Rename this value to something reasonable.
          let! foo1 = match_fun <| concl th'
          return! MP (Choice.result foo1) th
          }
          |> Choice.mapError (fun e -> nestedFailure e "MATCH_MP: No match")
  
  (* ------------------------------------------------------------------------- *)
  (* Useful instance of more general higher order matching.                    *)
  