anchor.diff:          let decs = res.AssemblyContents.ImplementationFiles.Head.Declarations
           for implFile in res.AssemblyContents.ImplementationFiles do
             for decl in implFile.Declarations do
  +              (* failwithf "%A" decl *)
                 let m = processDecl decl
  -              (* printfn "%A" m *)
                 cerl.prt m |> printfn "%s"
           0
       | _ ->
  
positive.code:     let processModDecl decl =
        match decl with
        | MemberOrFunctionOrValue(memb, Parameters ps, expr)
            when memb.IsModuleValueOrMember ->
                (* printfn "expr %A" expr *)
                let nm = Map.empty
                let args, nm = foldNames nm (safeVar true) (List.map fst ps)
                let e, nm = processExpr nm expr
                let l = lambda args e
                //TODO make function name safe
                let f = mkFunction memb.LogicalName (List.length ps)
                f, funDef f l
        | x -> failwithf "cannot process %A" x
  
  
      let processDecl decl =
        match decl with
        | Entity(ent, declList) when ent.IsFSharpModule ->
            let (funs, funDefs) =
                declList
                |> List.map processModDecl
                |> List.unzip
            cerl.Module (cerl.Atom ent.LogicalName, funs, [], funDefs)
        | InitAction(expr) ->
            failwithf "Init Action not supported %A" expr
        | x -> failwithf "cannot process %A" x
  
  [<EntryPoint>]
  let main argv =
  
negative.code: 
      let (|Lit|_|) = castLiteral
  
      let tupleGet idx e =
          let erlang = litAtom "erlang" |> constr
          let element = litAtom "element" |> constr
          let idx = idx+1 |> cerl.LInt
          modCall erlang element [cerl.Lit idx |> constr; e]
  
      //TODO: should we consult the FSharpType as well?
      let mapConst (o : obj) =
          match o with
  