Perf optimization - Seq.toArray

commit 51c9c233f825b56b6752cb0048f4af62625c76c1
Merge: e6300567 7fc4873
Author: latkin <latkin@microsoft.com>
Date:   Tue Oct 21 13:48:17 2014 -0700

    Merge branch 'master' of https://git01.codeplex.com/forks/reedcopsey/fsharpseqperf into PR

commit 7fc487317e19b31f6e8b6be54676695fa233599e
Author: ReedCopsey <reed@reedcopsey.com>
Date:   Tue Aug 26 11:32:55 2014 -0700

    Switched array construction to use Array.zeroCreateUnchecked

commit 89fd97d30111d3c1e730bb4fa602d9ea60b944e3
Author: ReedCopsey <reed@reedcopsey.com>
Date:   Fri Aug 22 17:34:47 2014 -0700

    Removed duplicate test assertion

commit 505dd63f2122a71b0ca5c470ecaab4281cde71fd
Author: ReedCopsey <reed@reedcopsey.com>
Date:   Fri Aug 22 17:32:16 2014 -0700

    Added test for empty input to Seq.toArray

commit 59db07b5a2af3dd838cbcf9d5ea252a5346159ce
Author: ReedCopsey <reed@reedcopsey.com>
Date:   Fri Aug 22 17:25:10 2014 -0700

    Optimized ICollection<T> and wildcard path in Seq.toArray.  Added tests to handle ICollection/Array/List input.

    Provides 4x or more speedups when using large ResizeArray or other ICollection<T> as input.

src/fsharp/FSharp.Core.Unittests/FSharp.Core/Microsoft.FSharp.Collections/SeqModule2.fs

@@ -989,13 +989,13 @@ type SeqModule2() =
         ()
         
     [<Test>]
-    member this.To_Array() =
+    member this.ToArray() =
         // integer Seq
         let resultInt = Seq.toArray(seq [1;2;4;5;7])
      
         let expectedInt = [|1;2;4;5;7|]
         Assert.AreEqual(expectedInt,resultInt)
-        
+
         // string Seq
         let resultStr =Seq.toArray (seq ["str1";"str2";"str3"])
     
@@ -1006,13 +1006,37 @@ type SeqModule2() =
         let resultEpt = Seq.toArray Seq.empty 
         Assert.AreEqual([||],resultEpt)
         
-         
         // null Seq
         CheckThrowsArgumentNullException(fun() -> Seq.toArray null |> ignore)
         ()
+        
+    [<Test>]    
+    member this.ToArrayFromICollection() =
+        let inputCollection = ResizeArray(seq [1;2;4;5;7])
+        let resultInt = Seq.toArray(inputCollection)
+        let expectedInt = [|1;2;4;5;7|]
+        Assert.AreEqual(expectedInt,resultInt)        
     
+    [<Test>]    
+    member this.ToArrayEmptyInput() =
+        let resultInt = Seq.toArray(Seq.empty<int>)
+        let expectedInt = Array.empty<int>
+        Assert.AreEqual(expectedInt,resultInt)        
+
+    [<Test>]    
+    member this.ToArrayFromArray() =
+        let resultInt = Seq.toArray([|1;2;4;5;7|])
+        let expectedInt = [|1;2;4;5;7|]
+        Assert.AreEqual(expectedInt,resultInt)        
+    
+    [<Test>]    
+    member this.ToArrayFromList() =
+        let resultInt = Seq.toArray([1;2;4;5;7])
+        let expectedInt = [|1;2;4;5;7|]
+        Assert.AreEqual(expectedInt,resultInt)        
+
     [<Test>]
-    member this.To_List() =
+    member this.ToList() =
         // integer Seq
         let resultInt = Seq.toList (seq [1;2;4;5;7])
         let expectedInt = [1;2;4;5;7]

src/fsharp/FSharp.Core/seq.fs

@@ -1109,12 +1109,14 @@ namespace Microsoft.FSharp.Collections
             match source with 
             | :? ('T[]) as res -> (res.Clone() :?> 'T[])
             | :? ('T list) as res -> List.toArray res
-            //| :? ICollection<'T> as res -> ...
+            | :? ICollection<'T> as res -> 
+                // Directly create an array and copy ourselves. 
+                // This avoids an extra copy if using ResizeArray in fallback below.
+                let arr = Array.zeroCreateUnchecked res.Count
+                res.CopyTo(arr, 0)
+                arr
             | _ -> 
-                use e = source.GetEnumerator()
-                let res = new ResizeArray<_>()
-                while e.MoveNext() do
-                    res.Add(e.Current)
+                let res = ResizeArray<_>(source)                
                 res.ToArray()