anchor.diff:          | _ when PicklerPluginRegistry.ContainsFactory shape.Type ->
               shape.Accept {
                   new ITypeShapeVisitor<Pickler> with
  -                    member __.Visit<'T> () = PicklerPluginRegistry.GetPicklerFactory<'T>() resolver :> Pickler }
  +                    member __.Visit<'T> () = PicklerPluginRegistry.GetPicklerFactory<'T>() resolver :> Pickler 
  +            }
  +
  +        | Shape.Nullable s ->
  +            s.Accept {
  +                new INullableVisitor<Pickler> with
  +                    member __.Visit<'T when 'T : struct and 'T :> ValueType and 'T : (new : unit -> 'T)> () =
  +                        NullablePickler.Create<'T>(resolver) :> _
  +            }
  +
  +        | Shape.Array s ->
  +            s.Accept {
  +                new IArrayVisitor<Pickler> with
  +                    member __.Visit<'T> () = ArrayPickler.Create<'T>(resolver) :> _
  +            }
  +
  +        | Shape.Array2D s ->
  +            s.Accept {
  +                new IArray2DVisitor<Pickler> with
  +                    member __.Visit<'T> () = ArrayPickler.Create2D<'T>(resolver) :> _
  +            }
  +
  +        | Shape.Array3D s ->
  +            s.Accept {
  +                new IArray3DVisitor<Pickler> with
  +                    member __.Visit<'T> () = ArrayPickler.Create3D<'T>(resolver) :> _
  +            }
  +
  +        | Shape.Array4D s ->
  +            s.Accept {
  +                new IArray4DVisitor<Pickler> with
  +                    member __.Visit<'T> () = ArrayPickler.Create4D<'T>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple1 s ->
  +            s.Accept {
  +                new ITuple1Visitor<Pickler> with
  +                    member __.Visit<'T1> () = TuplePickler.Create<'T1>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple2 s ->
  +            s.Accept {
  +                new ITuple2Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2> () = TuplePickler.Create<'T1, 'T2>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple3 s ->
  +            s.Accept {
  +                new ITuple3Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2, 'T3> () = TuplePickler.Create<'T1, 'T2, 'T3>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple4 s ->
  +            s.Accept {
  +                new ITuple4Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2, 'T3, 'T4> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple5 s ->
  +            s.Accept {
  +                new ITuple5Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple6 s ->
  +            s.Accept {
  +                new ITuple6Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5, 'T6>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple7 s ->
  +            s.Accept {
  +                new ITuple7Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>(resolver) :> _
  +            }
  +
  +        | Shape.Tuple8 s ->
  +            s.Accept {
  +                new ITuple8Visitor<Pickler> with
  +                    member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRest> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRest>(resolver) :> _
  +            }
  +
  +        | Shape.Dictionary s ->
  +            s.Accept {
  +                new IDictionaryVisitor<Pickler> with
  +                    member __.Visit<'K,'V when 'K : equality>() = DictionaryPickler.Create<'K,'V>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpList s ->
  +            s.Accept {
  +                new IFSharpListVisitor<Pickler> with
  +                    member __.Visit<'T> () = ListPickler.Create<'T>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpOption s ->
  +            s.Accept {
  +                new IFSharpOptionVisitor<Pickler> with
  +                    member __.Visit<'T> () = OptionPickler.Create<'T>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpRef s ->
  +            s.Accept {
  +                new IFSharpRefVisitor<Pickler> with
  +                    member __.Visit<'T> () = FSharpRefPickler.Create<'T>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpSet s ->
  +            s.Accept {
  +                new IFSharpSetVisitor<Pickler> with
  +                    member __.Visit<'T when 'T : comparison> () = FSharpSetPickler.Create<'T>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpMap s ->
  +            s.Accept {
  +                new IFSharpMapVisitor<Pickler> with
  +                    member __.Visit<'K,'V when 'K : comparison> () = FSharpMapPickler.Create<'K,'V>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpChoice2 s ->
  +            s.Accept {
  +                new IFSharpChoice2Visitor<Pickler> with
  +                    member __.Visit<'T1,'T2>() = ChoicePickler.Create<'T1,'T2>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpChoice3 s ->
  +            s.Accept {
  +                new IFSharpChoice3Visitor<Pickler> with
  +                    member __.Visit<'T1,'T2,'T3> () = ChoicePickler.Create<'T1,'T2,'T3>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpChoice4 s ->
  +            s.Accept {
  +                new IFSharpChoice4Visitor<Pickler> with
  +                    member __.Visit<'T1,'T2,'T3,'T4> () = ChoicePickler.Create<'T1,'T2,'T3,'T4>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpChoice5 s->
  +            s.Accept {
  +                new IFSharpChoice5Visitor<Pickler> with
  +                    member __.Visit<'T1,'T2,'T3,'T4,'T5> () = ChoicePickler.Create<'T1,'T2,'T3,'T4,'T5>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpChoice6 s ->
  +            s.Accept {
  +                new IFSharpChoice6Visitor<Pickler> with
  +                    member __.Visit<'T1,'T2,'T3,'T4,'T5,'T6> () = ChoicePickler.Create<'T1,'T2,'T3,'T4,'T5,'T6>(resolver) :> _
  +            }
  +
  +        | Shape.FSharpChoice7 s ->
  +            s.Accept {
  +                new IFSharpChoice7Visitor<Pickler> with
  +                    member __.Visit<'T1,'T2,'T3,'T4,'T5,'T6,'T7> () = ChoicePickler.Create<'T1,'T2,'T3,'T4,'T5,'T6,'T7>(resolver) :> _
  +            }
  +
  +        //////////////////////////////////
  +        // User-defined types
  +        //////////////////////////////////
   
           | _ when containsAttr<CloneableOnlyAttribute> shape.Type ->
               shape.Accept {
  
positive.code:                 new IDelegateVisitor<Pickler> with
                      member __.Visit<'D when 'D :> Delegate> () =
                          DelegatePickler.Create<'D>(resolver) :> _
              }
  
          | Shape.Array s ->
              s.Accept {
                  new IArrayVisitor<Pickler> with
                      member __.Visit<'T> () = ArrayPickler.Create<'T>(resolver) :> _
              }
  
          | Shape.Array2D s ->
              s.Accept {
                  new IArray2DVisitor<Pickler> with
                      member __.Visit<'T> () = ArrayPickler.Create2D<'T>(resolver) :> _
              }
  
          | Shape.Array3D s ->
              s.Accept {
                  new IArray3DVisitor<Pickler> with
                      member __.Visit<'T> () = ArrayPickler.Create3D<'T>(resolver) :> _
              }
  
          | Shape.Array4D s ->
              s.Accept {
                  new IArray4DVisitor<Pickler> with
                      member __.Visit<'T> () = ArrayPickler.Create4D<'T>(resolver) :> _
              }
  
          | Shape.Tuple1 s ->
              s.Accept {
                  new ITuple1Visitor<Pickler> with
                      member __.Visit<'T1> () = TuplePickler.Create<'T1>(resolver) :> _
              }
  
          | Shape.Tuple2 s ->
              s.Accept {
                  new ITuple2Visitor<Pickler> with
                      member __.Visit<'T1, 'T2> () = TuplePickler.Create<'T1, 'T2>(resolver) :> _
              }
  
          | Shape.Tuple3 s ->
              s.Accept {
                  new ITuple3Visitor<Pickler> with
                      member __.Visit<'T1, 'T2, 'T3> () = TuplePickler.Create<'T1, 'T2, 'T3>(resolver) :> _
              }
  
          | Shape.Tuple4 s ->
              s.Accept {
                  new ITuple4Visitor<Pickler> with
                      member __.Visit<'T1, 'T2, 'T3, 'T4> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4>(resolver) :> _
              }
  
          | Shape.Tuple5 s ->
              s.Accept {
                  new ITuple5Visitor<Pickler> with
                      member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5>(resolver) :> _
              }
  
          | Shape.Tuple6 s ->
              s.Accept {
                  new ITuple6Visitor<Pickler> with
                      member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5, 'T6>(resolver) :> _
              }
  
          | Shape.Tuple7 s ->
              s.Accept {
                  new ITuple7Visitor<Pickler> with
                      member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>(resolver) :> _
              }
  
          | Shape.Tuple8 s ->
              s.Accept {
                  new ITuple8Visitor<Pickler> with
                      member __.Visit<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRest> () = TuplePickler.Create<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRest>(resolver) :> _
              }
  
          | Shape.Dictionary s ->
              s.Accept {
                  new IDictionaryVisitor<Pickler> with
                      member __.Visit<'K,'V when 'K : equality>() = DictionaryPickler.Create<'K,'V>(resolver) :> _
              }
  
          | Shape.FSharpList s ->
              s.Accept {
                  new IFSharpListVisitor<Pickler> with
                      member __.Visit<'T> () = ListPickler.Create<'T>(resolver) :> _
              }
  
          | Shape.FSharpOption s ->
              s.Accept {
                  new IFSharpOptionVisitor<Pickler> with
                      member __.Visit<'T> () = OptionPickler.Create<'T>(resolver) :> _
              }
  
          | Shape.FSharpRef s ->
              s.Accept {
                  new IFSharpRefVisitor<Pickler> with
                      member __.Visit<'T> () = FSharpRefPickler.Create<'T>(resolver) :> _
              }
  
          | Shape.FSharpSet s ->
              s.Accept {
                  new IFSharpSetVisitor<Pickler> with
                      member __.Visit<'T when 'T : comparison> () = FSharpSetPickler.Create<'T>(resolver) :> _
              }
  
          | Shape.FSharpMap s ->
              s.Accept {
                  new IFSharpMapVisitor<Pickler> with
                      member __.Visit<'K,'V when 'K : comparison> () = FSharpMapPickler.Create<'K,'V>(resolver) :> _
              }
  
          | Shape.FSharpChoice2 s ->
              s.Accept {
                  new IFSharpChoice2Visitor<Pickler> with
                      member __.Visit<'T1,'T2>() = ChoicePickler.Create<'T1,'T2>(resolver) :> _
              }
  
          | Shape.FSharpChoice3 s ->
              s.Accept {
                  new IFSharpChoice3Visitor<Pickler> with
                      member __.Visit<'T1,'T2,'T3> () = ChoicePickler.Create<'T1,'T2,'T3>(resolver) :> _
              }
  
          | Shape.FSharpChoice4 s ->
              s.Accept {
                  new IFSharpChoice4Visitor<Pickler> with
                      member __.Visit<'T1,'T2,'T3,'T4> () = ChoicePickler.Create<'T1,'T2,'T3,'T4>(resolver) :> _
              }
  
          | Shape.FSharpChoice5 s->
              s.Accept {
                  new IFSharpChoice5Visitor<Pickler> with
                      member __.Visit<'T1,'T2,'T3,'T4,'T5> () = ChoicePickler.Create<'T1,'T2,'T3,'T4,'T5>(resolver) :> _
              }
  
          | Shape.FSharpChoice6 s ->
              s.Accept {
                  new IFSharpChoice6Visitor<Pickler> with
                      member __.Visit<'T1,'T2,'T3,'T4,'T5,'T6> () = ChoicePickler.Create<'T1,'T2,'T3,'T4,'T5,'T6>(resolver) :> _
              }
  
          | Shape.FSharpChoice7 s ->
              s.Accept {
                  new IFSharpChoice7Visitor<Pickler> with
                      member __.Visit<'T1,'T2,'T3,'T4,'T5,'T6,'T7> () = ChoicePickler.Create<'T1,'T2,'T3,'T4,'T5,'T6,'T7>(resolver) :> _
              }
  
          | Shape.FSharpUnion _ as s ->
  
negative.code:                     member __.Visit<'T> () = CustomPickler.Create<'T> resolver :> Pickler
              }
  
          | Shape.Enum s -> 
              // NB: DataContractAttribute for enum types handled by enum pickler
              s.Accept { 
                  new IEnumVisitor<Pickler> with
                      member __.Visit<'E, 'U when 'E : enum<'U>>() = EnumPickler.Create<'E, 'U>(resolver) :> _
              }
  
          | _ when containsAttr<DataContractAttribute> shape.Type ->
              shape.Accept {
                  new ITypeShapeVisitor<Pickler> with
                      member __.Visit<'T> () = DataContractPickler.Create<'T> resolver :> Pickler
              }
  
          | Shape.Delegate s ->
  