anchor.diff:                              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
  +                            // 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) ->
  
positive.code:             let guardExps = modCall erlang eq [leftExps; rightExps] |> constr
              cerl.PVar "_", cerl.Guard guardExps, nm
          | B.Let ((v, B.UnionCaseGet(_, IsFSharpList t, _, IsField "Tail" fld)), expr) ->
              (* printfn "processPat let tail expr %A" expr *)
              let v, nm = safeVar true nm v.LogicalName
              let thisPat = cerl.PList (cerl.LL ([], cerl.PVar v))
              // recurse over let binding patterns
              // maybe all this should be guards
              let guard, nm = processExpr nm expr
              let pat = thisPat
              pat, cerl.Guard guard, nm
          | B.Let ((v, B.UnionCaseGet(_, IsFSharpList t, _, IsField "Head" fld)), expr) ->
              let v, nm = safeVar true nm v.LogicalName
              (* printfn "processPat let head this %A gurad %A expr %A" thisPat guard expr *)
              let thisPat = cerl.PList(cerl.LL ([cerl.PVar v], cerl.PVar "_"))
              let guard, nm = processExpr nm expr
              let pat = thisPat
  
negative.code:                                     ((v, e) :: agg), nm) ([], nm)
  
                              let e, _ = processExpr nm e
                              let vls = List.map fst assignments
                              let es = List.choose (fun (_, e) ->
                                              match e with
  