anchor.diff:  
   let rec mkGenerator<'T> () : Gen<'T> =
       let wrap (t : Gen<'a>) = unbox<Gen<'T>> t
  +    let mkRandomMember (shape : IShapeWriteMember<'DeclaringType>) =
  +        shape.Accept { new IWriteMemberVisitor<'DeclaringType, Random -> 'DeclaringType -> 'DeclaringType> with
  +            member __.Visit (shape : ShapeWriteMember<'DeclaringType, 'Field>) =
  +                let rf = mkGenerator<'Field>()
  +                fun r dt -> shape.Inject dt (rf r) }
  +
       match TypeShape.Create<'T>() with
       | Shape.Unit -> wrap ignore
       | Shape.Byte -> wrap(fun r -> r.Next() |> byte)
  
positive.code:                     wrap(fun r -> t1G r, t2G r, t3G r)
          }
  
      | Shape.Array s ->
          s.Accept {
              new IArrayVisitor<Gen<'T>> with
                  member __.Visit<'t> () =
                      let tG = mkGenerator<'t>()
                      wrap(fun r -> 
                          let length = r.Next(100)
  
negative.code:                     wrap(fun r -> kvG r |> Map.ofArray)
          }
  
      | Shape.FSharpRecord s ->
          s.Accept { new IFSharpRecordVisitor<Gen<'T>> with
              member __.Visit (shape : ShapeFSharpRecord<'Record>) =
                  let fieldGen = shape.Fields |> Array.map mkRandomMember
                  wrap(fun r ->
                      let mutable init = shape.CreateUninitialized()
                      for f in fieldGen do init <- f r init
                      init) }
  
      | Shape.FSharpUnion s ->
          s.Accept { new IFSharpUnionVisitor<Gen<'T>> with
              member __.Visit (shape : ShapeFSharpUnion<'Union>) =
                  let caseFieldGen = shape.UnionCases |> Array.map (fun uc -> uc.Fields |> Array.map mkRandomMember)
                  wrap(fun r ->
                      let tag = r.Next shape.UnionCases.Length
                      let mutable u = shape.UnionCases.[tag].CreateUninitialized()
                      for f in caseFieldGen.[tag] do u <- f r u 
                      u) }
  
      | _ -> failwithf "Type %O does not support random value generation." typeof<'T>
  
  