anchor.diff:                                      ((v, e) :: agg), nm) ([], nm)
   
                               let e, _ = processExpr nm e
  -                            (* printfn "merged pat %A" pat *)
                               let vls = List.map fst assignments
                               let es = List.choose (fun (_, e) ->
                                               match e with
  
positive.code:                             let e =
                                  cerl.Let ((vls, cerl.Exps (cerl.Constr es)), e)
                              // we can throw away nm now as have branched
  
                              // TODO if e is a let it should be in pattern
                              altExpr (cerl.Pat pat, grd, e |> constr))
                  cerl.Case (caseExpr, alts), nm
              | B.FSharpFieldGet (Some e, t, fld) ->
  
negative.code:       match decl with
        | MemberOrFunctionOrValue(memb, Parameters ps, expr)
            when memb.IsModuleValueOrMember && not memb.IsCompilerGenerated ->
                let nm = Map.empty
                let args, nm = foldNames nm (safeVar true) (List.map fst ps)
                let e, nm = processExpr nm expr
  