anchor.diff:              |> Some
           | _ -> None
   
  -    let (|FSharpMap|_|) (s : TypeShape) =
  -        match s.ShapeInfo with
  -        | Generic(td,ta) when td = typedefof<Map<_,_>> -> 
  -            Activator.CreateInstanceGeneric<ShapeFSharpMap<_,_>>(ta)
  -            :?> IShapeFSharpMap
  -            |> Some
  -        | _ -> None
  -
  +    /// Recognizes shapes of F# function types
       let (|FSharpFunc|_|) (s : TypeShape) =
           if FSharpType.IsFunction s.Type then
               let d,c = FSharpType.GetFunctionElements s.Type
  
positive.code:         obj :?> 'Tuple
  
      interface IShapeTuple with
          member __.Accept v = v.Visit __
  
  // F# Records
  
  type IShapeFSharpRecord =
      abstract Fields : IShapeMember[]
      abstract Accept : IFSharpRecordVisitor<'R> -> 'R
  
  and ShapeFSharpRecord<'TRecord> private () =
      let props = FSharpType.GetRecordFields(typeof<'TRecord>, allMembers)
      let fields = typeof<'TRecord>.GetFields(allInstanceMembers)
      let mkRecordField (prop : PropertyInfo) (field : FieldInfo) =
          mkWriteMemberUntyped<'TRecord> prop.Name prop [|field :> MemberInfo|]
  
      let recordFields = Array.map2 mkRecordField props fields
  
      member inline __.CreateUninitialized() = 
          FormatterServices.GetUninitializedObject(typeof<'TRecord>) :?> 'TRecord
  
      member __.Fields = recordFields
  
      interface IShapeFSharpRecord with
          member __.Fields = recordFields |> Array.map unbox
          member __.Accept v = v.Visit __
  
  and IFSharpRecordVisitor<'R> =
      abstract Visit : ShapeFSharpRecord<'TRecord> -> 'R
  
  // F# Unions
  
  type IShapeFSharpUnionCase =
      abstract UnionCaseInfo : UnionCaseInfo
      abstract Fields : IShapeMember[]
  
  type ShapeFSharpUnionCase<'U> private (uci : UnionCaseInfo) =
      let properties = uci.GetFields()
      let ctorInfo = FSharpValue.PreComputeUnionConstructorInfo(uci, allMembers)
  
negative.code: 
              Array.map2 mkField fields properties
  
      /// Underlying FSharp.Reflection.UnionCaseInfo description
      member __.CaseInfo = uci
      /// Field shapes for union case
      member __.Fields = caseFields
  
      /// Creates an uninitialized instance for specific union case
      member __.CreateUninitialized() : 'U =
          ctorInfo.Invoke(null, ctorParams) :?> 'U
  
      interface IShapeFSharpUnionCase with
          member __.CaseInfo = uci
          member __.Fields = caseFields |> Array.map (fun f -> f :> _)
  
  /// Denotes an F# Union shape
  type IShapeFSharpUnion =
      /// Case shapes for given union type
      abstract UnionCases : IShapeFSharpUnionCase[]
      abstract Accept : IFSharpUnionVisitor<'R> -> 'R
  
  /// Denotes an F# Union shape
  and ShapeFSharpUnion<'U> private () =
      let ucis = 
          FSharpType.GetUnionCases(typeof<'U>, allMembers)
  