anchor.diff:  
           and print_clauses cls = 
               match cls with
  -            | [c] -> print_clause c
  +            | [c] ->
  +                print_clause c
               | c :: cs -> 
  -                (print_clause c
  -                 pp_print_break fmt 1 0
  -                 pp_print_string fmt "| "
  -                 print_clauses cs)
  -            | _ -> failwith "print_clauses: Unhandled case."
  +                print_clause c
  +                pp_print_break fmt 1 0
  +                pp_print_string fmt "| "
  +                print_clauses cs
  +            | _ ->
  +                failwith "print_clauses: Unhandled case."
   
           and print_clause cl = 
               match cl with
               | [p; g; r] -> 
  -                (print_term 1 p
  -                 pp_print_string fmt " when "
  -                 print_term 1 g
  -                 pp_print_string fmt " -> "
  -                 print_term 1 r)
  +                print_term 1 p
  +                pp_print_string fmt " when "
  +                print_term 1 g
  +                pp_print_string fmt " -> "
  +                print_term 1 r
               | [p; r] -> 
  -                (print_term 1 p
  -                 pp_print_string fmt " -> "
  -                 print_term 1 r)
  -            | _ -> failwith "print_clause: Unhandled case."
  +                print_term 1 p
  +                pp_print_string fmt " -> "
  +                print_term 1 r
  +            | _ ->
  +                failwith "print_clause: Unhandled case."
   
           fun tm ->
               try
                   print_term 0 tm
  -            with Failure s ->
  +            with Failure s as ex ->
  +                (* NOTE :   We currently suppress certain exceptions which may be raised during
  +                            printing; however, we do log them for diagnostics purposes. *)
  +                logger.DebugException ("Suppressed exception in 'pp_print_term'.", ex)
  +
                   // NOTE: suppress all exceptions in printing
                   ()
   
  
positive.code: /// Prints a term (without quotes) to formatter.
  let pp_print_term =
      let reverse_interface(s0, ty0) =
          if not(!reverse_interface_mapping) then s0
          else 
              match find (fun (s, (s', ty)) -> s' = s0 && Choice.isResult <| type_match ty ty0 []) (!the_interface) with
              | Some(s0', _) -> s0'
              | None -> s0
  
      let rec DEST_BINARY c tm = 
          choice { 
              let! il, r = dest_comb tm
              let! i, l = dest_comb il
              let! ci = dest_const i
              let! cc = dest_const c
              if i = c || (is_const i && is_const c && reverse_interface ci = reverse_interface cc) then 
                  return (l, r)
              else
                  return! Choice.fail()
          }        
          |> Choice.mapError (fun e -> nestedFailure e "DEST_BINARY")
  
      and ARIGHT s =
  
negative.code:             let! tm'' = body tm'
              let pbod = snd(strip_exists tm'')
              let s, args = strip_comb pbod
              // OPTIMIZE : Use pattern-matching here instead of 'length' -- it's faster because length is O(n).
              if name_of s = "_UNGUARDED_PATTERN" && length args = 2 then
                  let! tm1 = rator(hd args)
                  let! tm2 = rator(hd(tl args))                
  