anchor.diff:      let tagReader = FSharpValue.PreComputeUnionTagReader(typeof<'Union>, AllMembers)
   #endif
   
  -    let caseNames = ucis |> Array.map (fun u -> u.CaseInfo.Name)
  +    let caseNames = lazy(ucis.Value |> Array.map (fun u -> u.CaseInfo.Name))
   
       member _.IsStructUnion = typeof<'Union>.IsValueType
   
       /// Case shapes for given union type
  -    member _.UnionCases = ucis
  +    member _.UnionCases = ucis.Value
       /// Gets the underlying tag id for given union instance
       [<MethodImpl(MethodImplOptions.AggressiveInlining)>]
       member _.GetTag (union : 'Union) : int =
  
positive.code: /// Denotes a type that behaves like a C# record:
  /// Carries a parameterless constructor and settable properties
  and [<Sealed>] ShapeCliMutable<'Record> private (defaultCtor : ConstructorInfo) =
      let properties =
          typeof<'Record>.GetProperties(AllInstanceMembers)
          |> Seq.filter (fun p -> p.CanRead && p.CanWrite && p.GetIndexParameters().Length = 0)
          |> Seq.map (fun p -> mkWriteMemberUntyped<'Record> p.Name p [|p|])
          |> Seq.toArray
  
  #if TYPESHAPE_EMIT
      let ctor = emitUninitializedCtor<'Record> defaultCtor
  
negative.code: and [<Sealed>] ShapeTuple<'Tuple> private () =
      let tupleInfo = mkTupleInfo typeof<'Tuple>
  
      let tupleElems = lazy(
          gatherTupleMembers tupleInfo
          |> Seq.mapi (fun i (pI, path) -> 
              let label = sprintf "Item%d" (i+1)
              mkWriteMemberUntyped<'Tuple> label pI path)
          |> Seq.toArray)
  
      let ctorf = 
          let fieldStack = gatherNestedFields tupleInfo
          if typeof<'Tuple>.IsValueType then null
  #if TYPESHAPE_EMIT
          elif fieldStack.Length = 0 then
              let ctor = typeof<'Tuple>.GetConstructors().[0]
              emitUninitializedCtor<'Tuple> ctor
  #endif
          else
              // slow path: allocate nested tuple values as needed
              Func<_>(fun () ->
                  let tuple = FormatterServices.GetUninitializedObject typeof<'Tuple>
                  let mutable currentTuple = tuple
                  for f in fieldStack do
                      let nestedTuple = FormatterServices.GetUninitializedObject f.FieldType
                      f.SetValue(currentTuple, nestedTuple)
                      currentTuple <- nestedTuple
                  tuple :?> 'Tuple)
  
      member _.IsStructTuple = typeof<'Tuple>.IsValueType
      /// Tuple element shape definitions
      member _.Elements = tupleElems.Value
      /// Creates an uninitialized tuple instance of given type
      [<MethodImpl(MethodImplOptions.AggressiveInlining)>]
      member _.CreateUninitialized() : 'Tuple =
          if typeof<'Tuple>.IsValueType then Unchecked.defaultof<'Tuple>
          else ctorf.Invoke()
  
  #if TYPESHAPE_EXPR
      member _.CreateUninitializedExpr() : Expr<'Tuple> =
          if typeof<'Tuple>.IsValueType then
              Expr.Cast<'Tuple>(Expr.DefaultValue typeof<'Tuple>)
          else
              let values = tupleElems.Value |> Seq.map (fun e -> getDefaultValueExpr e.Member.Type) |> Seq.toList
              Expr.Cast<'Tuple>(Expr.NewTuple(values))
  #endif
  
      interface IShapeTuple with
          member _.Elements = tupleElems.Value |> Array.map (fun e -> e :> _)
          member s.Accept v = v.Visit s
  
  //---------------------
  