anchor.diff:              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) ->
  +            // list cons pattern on tail
               (* 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) ->
  +            // list cons pattern on head
               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
  
positive.code:       match decl with
        | MemberOrFunctionOrValue(memb, Parameters ps, expr)
            when memb.IsModuleValueOrMember && not memb.IsCompilerGenerated ->
                (* printfn "memb %A" memb.LogicalName *)
                (* failwithf "expr %A" expr *)
                let nm = Map.empty
                let args, nm = foldNames nm (safeVar true) (List.map fst ps)
                let e, nm = processExpr nm expr
  
negative.code:                         cerl.Case (caseExpr, alts), nm
                  | x -> failwithf "unexpected if then else result %A" x
  
              | B.DecisionTree (B.IfThenElse (fi, _, _) as ite, branches) as tree ->
                  (* printfn "ite %A \r\nl %A" ite  l *)
                  // TODO: it wont always be vars
                  let caseExpr, nm = extractCaseExpr nm fi
  