anchor.diff:              match arity with
               | 0 -> typeof<unit>
               | 1 -> argTypes.[0]
  -            | _ -> FSharpType.MakeTupleType argTypes
  +            | _ -> FSharpType.MakeStructTupleType(typeof<int>.Assembly, argTypes)
   
           Activator.CreateInstanceGeneric<ShapeConstructor<_,_>>([|typeof<'Record>; argumentType|], [|box ctorInfo; box arity|])
           :?> IShapeConstructor<'Record>
   
   //--------------------
   // Generic Tuple Shape
  -
  -[<AutoOpen>]
  -module private ShapeTupleImpl =
  -
  -    [<NoEquality; NoComparison>]
  -    type TupleInfo =
  -        { 
  -            Current : Type
  -            Fields : (MemberInfo * FieldInfo) []
  -            Nested : (FieldInfo * TupleInfo) option
  -        }
  -
  -    let rec mkTupleInfo (t : Type) =
  -        if t.IsValueType then
  -            let fields = t.GetFields()
  -            let getField (f : FieldInfo) = f :> MemberInfo, f
  -            let fs, nested =
  -                if fields.Length = 8 then
  -                    let nestedField = fields.[7]
  -                    let nestedInfo = mkTupleInfo nestedField.FieldType
  -                    Array.map getField fields.[..6], Some(nestedField, nestedInfo)
  -                else
  -                    Array.map getField fields, None
  -
  -            { Current = t ; Fields = fs ; Nested = nested }
  -        else
  -            let props = t.GetProperties()
  -            let fields = t.GetFields(BindingFlags.NonPublic ||| BindingFlags.Instance)
  -            let getField (p : PropertyInfo) =
  -                let field = fields |> Array.find(fun f -> f.Name = "m_" + p.Name)
  -                p :> MemberInfo, field
  -
  -            let fs, nested =
  -                if props.Length = 8 then
  -                    let nestedField = fields.[7]
  -                    let nestedInfo = mkTupleInfo nestedField.FieldType
  -                    Array.map getField props.[..6], Some(nestedField, nestedInfo)
  -                else
  -                    Array.map getField props, None
  -
  -            { Current = t ; Fields = fs ; Nested = nested }
  -
  -    let gatherTupleMembers (tI : TupleInfo) =
  -        let rec aux (ctx : MemberInfo list) (tI : TupleInfo) = seq {
  -            for p,f in tI.Fields do
  -                yield p, f :> MemberInfo :: ctx |> List.rev |> List.toArray
  -
  -            match tI.Nested with
  -            | Some (fI,n) -> yield! aux (fI :> MemberInfo :: ctx) n
  -            | None -> ()
  -        }
  -
  -        aux [] tI
  -
  -    let gatherNestedFields (tI : TupleInfo) =
  -        let rec aux fs (tI : TupleInfo) =
  -            match tI.Nested with
  -            | Some (fI,n) -> aux (fI :: fs) n
  -            | _ -> List.rev fs
  -
  -        aux [] tI
  -        |> List.toArray
  -
  -//---------------------------
  -// Shape Tuple Implementation
   
   /// Denotes a specific System.Tuple shape
   type IShapeTuple =
  
positive.code: 
          emitDynamicMethod<Func<SerializationInfo, StreamingContext, 'T>> "serializableCtor" 
              [|typeof<SerializationInfo>; typeof<StreamingContext>|] typeof<'T> builder
  #endif
  
  //-------------------------
  
negative.code:         emitDynamicMethod<Setter<'DeclaringType, 'Property>>
              injectionId [|typeof<'DeclaringType>.MakeByRefType(); typeof<'Property>|] typeof<System.Void> builder
  
      let ldDefaultValue (gen : ILGenerator) (t : Type) =
          if not t.IsValueType then gen.Emit OpCodes.Ldnull
          elif t = typeof<bool> || t = typeof<byte> || t = typeof<sbyte> ||
              t = typeof<char> || t = typeof<uint16> || t = typeof<int16> ||
              t = typeof<int32> || t = typeof<uint32> then
              gen.Emit OpCodes.Ldc_I4_0
          elif t = typeof<int64> || t = typeof<uint64> then
              gen.Emit OpCodes.Ldc_I4_0 ; gen.Emit OpCodes.Conv_I8
          elif t = typeof<single> then gen.Emit(OpCodes.Ldc_R4, 0.0f)
          elif t = typeof<double> then gen.Emit(OpCodes.Ldc_R8, 0.0)
          elif t = typeof<IntPtr> then gen.Emit OpCodes.Ldc_I4_0; gen.Emit OpCodes.Conv_I
          elif t = typeof<UIntPtr> then gen.Emit OpCodes.Ldc_I4_0; gen.Emit OpCodes.Conv_U
          else
              assert(not t.IsPrimitive)
              let lvar = gen.DeclareLocal t
              gen.Emit(OpCodes.Ldloca_S, lvar.LocalIndex)
              gen.Emit(OpCodes.Initobj, t)
              gen.Emit(OpCodes.Ldloc, lvar.LocalIndex)
          
  
      /// Emits a dynamic method that injects uninitialized values to supplied static method or ctor
      let emitUninitializedCtor<'DeclaringType> (ctor : MethodBase) =
          let builder (gen : ILGenerator) =
              for p in ctor.GetParameters() do ldDefaultValue gen p.ParameterType
  
              match ctor with
              | :? ConstructorInfo as c -> gen.Emit(OpCodes.Newobj, c)
  