anchor.diff:                      wrap(fun r -> t1G r, t2G r, t3G r)
           }
   
  -    | Shape.Array s ->
  +    | Shape.Array s when s.Rank = 1 ->
           s.Accept {
               new IArrayVisitor<Gen<'T>> with
  -                member __.Visit<'t> () =
  +                member __.Visit<'t> _ =
                       let tG = mkGenerator<'t>()
                       wrap(fun r -> 
                           let length = r.Next(100)
  
positive.code: 
  let rec mkGenerator<'T> () : Gen<'T> =
      let wrap (t : Gen<'a>) = unbox<Gen<'T>> t
      match TypeShape.Create<'T>() with
      | Shape.Unit -> wrap ignore
      | Shape.Byte -> wrap(fun r -> r.Next() |> byte)
  
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>
  
  