anchor.diff:  
   /// Produces a case split based on a disjunctive theorem.
   let (DISJ_CASES_TAC : thm_tactic) = 
  -    fun dth g -> 
  -        let f = 
  -            let fun1 l i =
  -                match l with
  -                | [th1; th2] -> DISJ_CASES (INSTANTIATE_ALL i dth) th1 th2
  -                | _ -> Choice.failwith "DISJ_CASES_TAC.fun1: Unhandled case."
  -            let dtm = concl <| Choice.get dth
  -            let l, r = Choice.get <| dest_disj dtm
  -            let thl = ASSUME l
  -            let thr = ASSUME r
  -            fun (asl, w) -> 
  -                (null_meta, [("", thl) :: asl, w; ("", thr) :: asl, w], fun i tl -> fun1 tl i)
  -                |> Choice.result
  -        f g |> Choice.mapError (fun e -> nestedFailure e "DISJ_CASES_TAC: Failure.")
  +    fun dth ->         
  +        let fun1 l i =
  +            match l with
  +            | [th1; th2] -> DISJ_CASES (INSTANTIATE_ALL i dth) th1 th2
  +            | _ -> Choice.failwith "DISJ_CASES_TAC.fun1: Unhandled case."
  +        let dtm = Choice.map concl dth
  +        let lr = Choice.bind dest_disj dtm
  +        let thl = lr |> Choice.bind (fun (l, _) -> ASSUME l)
  +        let thr = lr |> Choice.bind (fun (_, r) -> ASSUME r)
  +        fun (asl, w) -> 
  +            choice {
  +                let! l, r = lr
  +                return (null_meta, [("", thl) :: asl, w; ("", thr) :: asl, w], fun i tl -> fun1 tl i)            
  +            }
  +            |> Choice.mapError (fun e -> nestedFailure e "DISJ_CASES_TAC: Failure.")
   
   /// Solves any goal from contradictory theorem.
   let (CONTR_TAC : thm_tactic) = 
  
positive.code:         SUBGOAL_THEN tm (LABEL_TAC s) |> THENL <| [p; ALL_TAC]
      |  [] -> fun _ -> Choice.failwith "SUBGOAL_TAC: no subproof given"
  
  /// 'Freezes' a theorem to prevent instantiation of its free Choice.get <| variables.
  let (FREEZE_THEN : thm_tactical) = 
      fun ttac th (asl, w) -> 
          ttac (ASSUME(concl <| Choice.get th)) (asl, w)
          |> Choice.bind (fun (meta, gl, just) ->
              (meta, gl, fun i l -> PROVE_HYP th (just i l))
              |> Choice.result)
  
  (* ------------------------------------------------------------------------- *)
  (* Metavariable tactics.                                                     *)
  
negative.code: /// Introduces a lemma as a new subgoal.
  let SUBGOAL_THEN : term -> thm_tactic -> tactic = 
      fun wa ttac (asl, w) -> 
          choice {
              let! (meta, gl, just) = ttac (ASSUME wa) (asl, w)
              return(meta, (asl, wa) :: gl, fun i l -> PROVE_HYP (hd l) (just i (tl l)))            
          }
  
  /// Encloses the sub-proof of a named lemma.
  let SUBGOAL_TAC s tm prfs =
  