anchor.diff:        let args = map_rev (fun (x, q) -> (readback env x, q)) ts in
         U.mk_app (S.bv_to_name bv) args
   
  -    | Accu (Match (scrut, cases, branches), ts) ->
  +    | Accu (Match (scrut, cases, patterns), ts) ->
         let args = map_rev (fun (x, q) -> (readback env x, q)) ts in
         let head = 
           let scrut_new = readback env scrut in
  -        let branches_new = 
  -          List.map (fun (pat, when_clause, _) -> pat, when_clause, readback env (cases (translate_pat pat))) 
  -                   branches 
  -        in
  +        let branches_new = patterns (readback env) in
           S.mk (Tm_match (scrut_new, branches_new)) None Range.dummyRange
         in
         (*  When `cases scrut` returns a Accu(Match ..))
  
positive.code: let mkConstruct i us ts = Construct(i, us, ts)
  
  let mkAccuVar (v:var) = Accu(Var v, [])
  let mkAccuMatch (s : t) (c : t -> t) (bs:list<branch>) = Accu(Match (s, c, bs), [])
  let mkAccuRec (b:letbinding) (bs:list<letbinding>) (env:list<t>) = Accu(Rec(b, bs, env), [])
  
  let isAccu (trm:t) =
  
negative.code:           | Some (branch, args) ->
              translate env (List.fold_left (fun bs x -> x::bs) bs args) branch
            | None -> //no branch is determined
              mkAccuMatch scrut case patterns
            end
          | Constant c ->
            (* same as for construted values, but args are either empty or is a singleton list (for wildcard patterns) *)
  