anchor.diff:              | Choice2Of3 msg -> failwithf "%A: %s" t msg
               | Choice3Of3 () -> None
   
  -        let encodeLambda name warn comp t =
  -            getEncoding name true warn comp t
  +        let encodeLambda name param t =
  +            getEncoding name true param t
               |> Option.map (fun x -> Application(x, [], true, Some 0))
   
  -        let encode name warn comp t arg =
  -            encodeLambda name warn comp t
  +        let encode name param t arg =
  +            encodeLambda name param t
               |> Option.map (fun x -> Application(x, [arg], true, Some 1))
   
  -        let decodeLambda name warn comp t =
  -            getEncoding name false warn comp t
  +        let decodeLambda name param t =
  +            getEncoding name false param t
               |> Option.map (fun x -> Application(x, [], true, Some 0))
   
  -        let decode name warn comp t arg =
  -            decodeLambda name warn comp t
  +        let decode name param t arg =
  +            decodeLambda name param t
               |> Option.map (fun x -> Application(x, [arg], true, Some 1))
   
  -    let Encode warn comp t arg =
  +    let Encode param t arg =
           // ENCODE()(arg)
  -        encode "Encode" warn comp t arg
  +        encode "Encode" param t arg
   
       let EncodeLambda warn t =
           // ENCODE()
           encodeLambda "EncodeLambda" warn t
   
  -    let Serialize warn comp t arg =
  +    let Serialize param t arg =
           // JSON.stringify(ENCODE()(arg))
  -        encode "Serialize" warn comp t arg
  -        |> Option.map (fun x -> mJson comp "Stringify" [x])
  -
  -    let SerializeLambda warn comp t =
  -        encodeLambda "SerializeLambda" warn comp t
  +        encode "Serialize" param t arg
  +        |> Option.map (fun x -> mJson param.Compilation "Stringify" [x])
  +
  +    let SerializeLambda param t =
  +        encodeLambda "SerializeLambda" param t
           |> Option.map (fun x ->
               let enc = Id.New(mut = false)
               let arg = Id.New(mut = false)
               // let enc = ENCODE() in fun arg -> JSON.stringify(enc(arg))
               Let(enc, x,
                   Lambda([arg],
  -                    mJson comp "Stringify" [Application(Var enc, [Var arg], true, Some 1)])))
  -
  -    let Decode warn comp t arg =
  +                    mJson param.Compilation "Stringify" [Application(Var enc, [Var arg], true, Some 1)])))
  +
  +    let Decode param t arg =
           // DECODE()(arg)
  -        decode "Decode" warn comp t arg
  -
  -    let DecodeLambda warn comp t =
  +        decode "Decode" param t arg
  +
  +    let DecodeLambda param t =
           // DECODE()
  -        decodeLambda "DecodeLambda" warn comp t
  -
  -    let Deserialize warn comp t arg =
  +        decodeLambda "DecodeLambda" param t
  +
  +    let Deserialize param t arg =
           // DECODE()(JSON.parse(arg))
  -        decode "Deserialize" warn comp t (mJson comp "Parse" [arg])
  -
  -    let DeserializeLambda warn comp t =
  -        decodeLambda "DeserializeLambda" warn comp t
  +        decode "Deserialize" param t (mJson param.Compilation "Parse" [arg])
  +
  +    let DeserializeLambda param t =
  +        decodeLambda "DeserializeLambda" param t
           |> Option.map (fun x ->
               let dec = Id.New(mut = false)
               let arg = Id.New(mut = false)
               // let dec = DECODE() in fun arg -> dec(JSON.parse(arg))
               Let(dec, x,
                   Lambda([arg],
  -                    Application(Var dec, [mJson comp "Parse" [Var arg]], true, Some 1))))
  +                    Application(Var dec, [mJson param.Compilation "Parse" [Var arg]], true, Some 1))))
   
       type SerializeMacro() =
           inherit WebSharper.Core.Macro()
  
positive.code: 
      type Parameters =
          {
              Warn : string -> unit
              Provider : Expression
          }
  
      [<AutoOpen>]
  
negative.code:                         )  
                      let pr =
                          match comp.GetClassInfo t.TypeDefinition |> Option.bind (fun cls -> cls.Address) with
                          | Some a -> 
                              addTypeDep t.TypeDefinition 
                              GlobalAccess a
                          | _ -> Undefined
                      if pr = Undefined && fieldEncoders |> List.forall (fun (_, fo, fe) ->
                          fo <> OptionalFieldKind.NormalOption &&
  