anchor.diff:          member s.IsPublic = isPublicMember
           member s.Accept v = v.Visit s
   
  -and IMemberVisitor<'Record, 'R> =
  -    abstract Visit<'MemberType> : ShapeMember<'Record, 'MemberType> -> 'R
  +and IMemberVisitor<'DeclaringType, 'R> =
  +    abstract Visit<'MemberType> : ShapeMember<'DeclaringType, 'MemberType> -> 'R
   
   //----------------------------
   // Writable Member Definitions
   
  +/// Identifies an instance member that defines
  +/// a mutable value in a class instance, typically a field or property
   type IShapeWriteMember<'Record> =
       inherit IShapeMember<'Record>
       abstract Accept : IWriteMemberVisitor<'Record,'R> -> 'R
   
  -and ShapeWriteMember<'Record, 'MemberType> private (label : string, memberInfo : MemberInfo, path : MemberInfo[], 
  -                                                        readOnly : ShapeMember<'Record, 'MemberType>) =
  +/// Identifies an instance member that defines
  +/// a mutable value in a class instance, typically a field or property
  +and ShapeWriteMember<'DeclaringType, 'MemberType> private (label : string, memberInfo : MemberInfo, path : MemberInfo[], 
  +                                                            readOnly : ShapeMember<'DeclaringType, 'MemberType>) =
       let isStructMember = isStructMember path
       let isPublicMember = isPublicMember memberInfo
   
  +    /// Human-readable member identifier
       member __.Label = label
  +    /// The actual System.Reflection.MemberInfo corresponding to member
       member __.MemberInfo = memberInfo
  +    /// True iff member is contained within a struct
       member __.IsStructMember = isStructMember
  +    /// True iff member is public
       member __.IsPublic = isPublicMember
  -
  -    member __.Project (r : 'Record) = 
  -        project<'Record, 'MemberType> path r
  +    /// Projects an instance to member of given value
  +    member __.Project (instance : 'DeclaringType) = 
  +        project<'DeclaringType, 'MemberType> path instance
           
  -    member __.ProjectExpr (r : Expr<'Record>) =
  -        projectExpr<'Record, 'MemberType> path r
  -
  -    member __.Inject (r : 'Record) (field : 'MemberType) : 'Record =
  -        inject<'Record, 'MemberType> false path r field
  -
  -    member __.InjectExpr (r : Expr<'Record>) (field : Expr<'MemberType>) =
  -        injectExpr path r field
  -
  -    interface IShapeMember<'Record> with
  +    /// Projects an instance to member of given value
  +    member __.ProjectExpr (instance : Expr<'DeclaringType>) =
  +        projectExpr<'DeclaringType, 'MemberType> path instance
  +
  +    /// Injects a value to member of given instance
  +    member __.Inject (instance : 'DeclaringType) (field : 'MemberType) : 'DeclaringType =
  +        inject<'DeclaringType, 'MemberType> false path instance field
  +
  +    /// Injects a value to member of given instance
  +    member __.InjectExpr (instance : Expr<'DeclaringType>) (field : Expr<'MemberType>) =
  +        injectExpr path instance field
  +
  +    interface IShapeMember<'DeclaringType> with
           member s.Label = label
           member s.MemberType = typeof<'MemberType>
           member s.MemberInfo = memberInfo
  
positive.code:             let instance = Activator.CreateInstanceGeneric<ShapeNotStruct<_>> [|s.Type|] :?> IShapeNotStruct
              NotStruct instance
  
      let (|DefaultConstructor|_|) (shape : TypeShape) =
          match shape.Type.GetConstructor(BindingFlags.Public ||| BindingFlags.Instance, null, [||], [||]) with
          | null -> None
  
negative.code:         else
              None
  
      /// Identifies whether shape satisfies the 'struct' or 'not struct' constraint
      let (|Struct|NotStruct|) (s : TypeShape) =
          if s.Type.IsValueType then
              let instance = Activator.CreateInstanceGeneric<ShapeStruct<_>> [|s.Type|] :?> IShapeStruct
  