anchor.diff:              norm cfg body_env stack body
   
             | Tm_meta (head, m) ->
  +            log cfg (fun () -> BU.print1 ">> metadata = %s\n" (Print.metadata_to_string m));
               begin match m with
                 | Meta_monadic (m, t) ->
                   reduce_impure_comp cfg env stack head (Inl m) t
  
positive.code:     end
  
    | App(env, head, aq, r)::stack' when should_reify cfg stack ->
      begin match (SS.compress t).n with
      | Tm_meta (t, Meta_monadic (m, ty)) ->
         log cfg (fun () -> BU.print1 "Will reify: %s \n" (stack_to_string stack));
         do_reify_monadic cfg env stack t m ty
  
      | Tm_meta (t, Meta_monadic_lift (m, m', ty)) ->
         log cfg (fun () -> BU.print1 "Will reify lift: %s \n" (stack_to_string stack));
         norm cfg env stack (reify_lift cfg.tcenv t m m' (closure_as_term cfg env ty))
  
      | _ ->
         log cfg (fun () -> BU.print1 "Not reifying: %s \n" (stack_to_string stack));
         let t = S.extend_app head (t,aq) None r in
         rebuild cfg env stack' (maybe_simplify cfg env stack' t)
      end
  
    | App(env, head, aq, r)::stack ->
  
negative.code:           (* An action was found and successfully unfolded *)
            | Some true -> body
          in
          norm cfg env (List.tl stack) body
  
      // Doubly-annotated effect.. just take the outmost one. (unsure..)
      | Tm_meta(e, Meta_monadic _) ->
          do_reify_monadic fallback cfg env stack e m t
  
      | Tm_meta(e, Meta_monadic_lift (msrc, mtgt, t')) ->
          let lifted = reify_lift cfg e msrc mtgt (closure_as_term cfg env t') in
          norm cfg env (List.tl stack) lifted
  
      | Tm_match(e, branches) ->
        (* Commutation of reify with match, note that the scrutinee should never be effectful    *)
        (* (should be checked at typechecking and elaborated with an explicit binding if needed) *)
  