replaced Random.replicate with ListRandom traverse and sequence

src/Hedgehog/Gen.fs

@@ -309,7 +309,10 @@ module Gen =
     let list (range : Range<int>) (g : Gen<'a>) : Gen<List<'a>> =
         Random.sized (fun size -> random {
             let! k = Random.integral range
-            let! xs = Random.replicate k (toRandom g)
+            let! xs =
+                toRandom g
+                |> List.replicate k
+                |> ListRandom.sequence
             return Shrink.sequenceList xs
                 |> Tree.filter (atLeast (Range.lowerBound size range))
         })
@@ -488,7 +491,8 @@ module Gen =
     let sampleTree (size : Size) (count : int) (g : Gen<'a>) : List<Tree<'a>> =
         let seed = Seed.random ()
         toRandom g
-        |> Random.replicate count
+        |> List.replicate count
+        |> ListRandom.sequence
         |> Random.run seed size
 
     let sample (size : Size) (count : int) (g : Gen<'a>) : List<'a> =

src/Hedgehog/Hedgehog.fsproj

@@ -33,6 +33,7 @@ https://github.com/hedgehogqa/fsharp-hedgehog/blob/master/doc/index.md
     <Compile Include="OptionTree.fs" />
     <Compile Include="Range.fs" />
     <Compile Include="Random.fs" />
+    <Compile Include="ListRandom.fs" />
     <Compile Include="Shrink.fs" />
     <Compile Include="Gen.fs" />
     <Compile Include="ListGen.fs" />

src/Hedgehog/ListRandom.fs

@@ -0,0 +1,16 @@
+[<RequireQualifiedAccess>]
+module Hedgehog.ListRandom
+
+let traverse (f: 'a -> Random<'b>) (list: List<'a>) : Random<List<'b>> =
+    let rec loop input output =
+        match input with
+        | [] -> output |> List.rev |> Random.constant
+        | a :: input ->
+            random {
+                let! b = f a
+                return! loop input (b :: output)
+            }
+    loop list []
+
+let sequence (randoms : List<Random<'a>>) : Random<List<'a>> =
+    randoms |> traverse id

src/Hedgehog/Random.fs

@@ -51,17 +51,6 @@ module Random =
     let bind (f: 'a -> Random<'b>) (r: Random<'a>) : Random<'b> =
         r |> map f |> join
 
-    let replicate (times: int) (r: Random<'a>) : Random<List<'a>> =
-        Random (fun seed0 size ->
-            let rec loop seed k acc =
-                if k <= 0 then
-                    acc
-                else
-                    let seed1, seed2 = Seed.split seed
-                    let x = unsafeRun seed1 size r
-                    loop seed2 (k - 1) (x :: acc)
-            loop seed0 times [])
-
     type Builder internal () =
         member __.Return(x : 'a) : Random<'a> =
             constant x