[WIP] [CompilerPerf] Seq - the next generation.

src/buildfromsource/FSharp.Core/FSharp.Core.fsproj

@@ -64,12 +64,30 @@
     <Compile Include="$(FsCoreDir)\collections.fs">
       <Link>Collections/collections.fs</Link>
     </Compile>
+    <Compile Include="$(FsCoreDir)\list.fsi">
+      <Link>Collections/list.fsi</Link>
+    </Compile>
+    <Compile Include=$(FsCoreDir)\"list.fs">
+      <Link>Collections/list.fs</Link>
+    </Compile>
+    <Compile Include="$(FsCoreDir)\array.fsi">
+      <Link>Collections/array.fsi</Link>
+    </Compile>
+    <Compile Include="$(FsCoreDir)\array.fs">
+      <Link>Collections/array.fs</Link>
+    </Compile>
     <Compile Include="$(FsCoreDir)\seqcore.fsi">
       <Link>Collections/seqcore.fsi</Link>
     </Compile>
     <Compile Include="$(FsCoreDir)\seqcore.fs">
       <Link>Collections/seqcore.fs</Link>
     </Compile>
+    <Compile Include="$(FsCoreDir)\iseq.fsi">
+      <Link>Collections/iseq.fsi</Link>
+    </Compile>
+    <Compile Include="$(FsCoreDir)\iseq.fs">
+      <Link>Collections/iseq.fs</Link>
+    </Compile>
     <Compile Include="$(FsCoreDir)\seq.fsi">
       <Link>Collections/seq.fsi</Link>
     </Compile>
@@ -95,7 +113,7 @@
       <Link>Collections/array.fs</Link>
     </Compile>
     <Compile Include="$(FsCoreDir)\array3.fsi">
-      <Link>Collections/array3.fsi</Link>
+      <Link>Collections/array.fsi</Link>
     </Compile>
     <Compile Include="$(FsCoreDir)\array3.fs">
       <Link>Collections/array3.fs</Link>

src/fsharp/FSharp.Core/FSharp.Core.fsproj

@@ -92,12 +92,30 @@
     <Compile Include="collections.fs">
       <Link>Collections/collections.fs</Link>
     </Compile>
+    <Compile Include="list.fsi">
+      <Link>Collections/list.fsi</Link>
+    </Compile>
+    <Compile Include="list.fs">
+      <Link>Collections/list.fs</Link>
+    </Compile>
+    <Compile Include="array.fsi">
+      <Link>Collections/array.fsi</Link>
+    </Compile>
+    <Compile Include="array.fs">
+      <Link>Collections/array.fs</Link>
+    </Compile>
     <Compile Include="seqcore.fsi">
       <Link>Collections/seqcore.fsi</Link>
     </Compile>
     <Compile Include="seqcore.fs">
       <Link>Collections/seqcore.fs</Link>
     </Compile>
+    <Compile Include="iseq.fsi">
+      <Link>Collections/iseq.fsi</Link>
+    </Compile>
+    <Compile Include="iseq.fs">
+      <Link>Collections/iseq.fs</Link>
+    </Compile>
     <Compile Include="seq.fsi">
       <Link>Collections/seq.fsi</Link>
     </Compile>
@@ -110,18 +128,6 @@
     <Compile Include="string.fs">
       <Link>Collections/string.fs</Link>
     </Compile>
-    <Compile Include="list.fsi">
-      <Link>Collections/list.fsi</Link>
-    </Compile>
-    <Compile Include="list.fs">
-      <Link>Collections/list.fs</Link>
-    </Compile>
-    <Compile Include="array.fsi">
-      <Link>Collections/array.fsi</Link>
-    </Compile>
-    <Compile Include="array.fs">
-      <Link>Collections/array.fs</Link>
-    </Compile>
     <Compile Include="array3.fsi">
       <Link>Collections/array3.fsi</Link>
     </Compile>

src/fsharp/FSharp.Core/array.fs

@@ -8,7 +8,6 @@ namespace Microsoft.FSharp.Collections
     open Microsoft.FSharp.Core
     open Microsoft.FSharp.Collections
     open Microsoft.FSharp.Core.Operators
-    open Microsoft.FSharp.Core.CompilerServices
     open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
 #if FX_RESHAPED_REFLECTION
     open System.Reflection
@@ -97,12 +96,22 @@ namespace Microsoft.FSharp.Collections
                 j <- j + len
             res               
 
+        [<CompiledName("ToSeq")>]
+        let toSeq array = 
+            checkNonNull "array" array
+            Microsoft.FSharp.Primitives.Basics.Array.toSeq array
+
+        [<CompiledName("OfSeq")>]
+        let ofSeq source = 
+            checkNonNull "source" source
+            Microsoft.FSharp.Primitives.Basics.Array.ofSeq source
+
         [<CompiledName("Concat")>]
         let concat (arrays: seq<'T[]>) = 
             checkNonNull "arrays" arrays
             match arrays with 
             | :? ('T[][]) as ts -> ts |> concatArrays // avoid a clone, since we only read the array
-            | _ -> arrays |> Seq.toArray |> concatArrays
+            | _ -> arrays |> ofSeq |> concatArrays
 
         [<CompiledName("Replicate")>]
         let replicate count initial = 
@@ -182,7 +191,7 @@ namespace Microsoft.FSharp.Collections
         let countByValueType (projection:'T->'Key) (array:'T[]) = countByImpl HashIdentity.Structural<'Key> projection id array
 
         // Wrap a StructBox around all keys in case the key type is itself a type using null as a representation
-        let countByRefType   (projection:'T->'Key) (array:'T[]) = countByImpl RuntimeHelpers.StructBox<'Key>.Comparer (fun t -> RuntimeHelpers.StructBox (projection t)) (fun sb -> sb.Value) array
+        let countByRefType   (projection:'T->'Key) (array:'T[]) = countByImpl StructBox<'Key>.Comparer (fun t -> StructBox (projection t)) (fun sb -> sb.Value) array
 
         [<CompiledName("CountBy")>]
         let countBy (projection:'T->'Key) (array:'T[]) =
@@ -432,7 +441,7 @@ namespace Microsoft.FSharp.Collections
         let groupByValueType (keyf:'T->'Key) (array:'T[]) = groupByImpl HashIdentity.Structural<'Key> keyf id array
 
         // Wrap a StructBox around all keys in case the key type is itself a type using null as a representation
-        let groupByRefType   (keyf:'T->'Key) (array:'T[]) = groupByImpl RuntimeHelpers.StructBox<'Key>.Comparer (fun t -> RuntimeHelpers.StructBox (keyf t)) (fun sb -> sb.Value) array
+        let groupByRefType   (keyf:'T->'Key) (array:'T[]) = groupByImpl StructBox<'Key>.Comparer (fun t -> StructBox (keyf t)) (fun sb -> sb.Value) array
 
         [<CompiledName("GroupBy")>]
         let groupBy (projection:'T->'Key) (array:'T[]) =
@@ -1051,16 +1060,6 @@ namespace Microsoft.FSharp.Collections
             let inline compareDescending a b = compare b a
             sortWith compareDescending array
 
-        [<CompiledName("ToSeq")>]
-        let toSeq array = 
-            checkNonNull "array" array
-            Seq.ofArray array
-
-        [<CompiledName("OfSeq")>]
-        let ofSeq source = 
-            checkNonNull "source" source
-            Seq.toArray source
-
         [<CompiledName("FindIndex")>]
         let findIndex predicate (array : _[]) = 
             checkNonNull "array" array
@@ -1256,7 +1255,7 @@ namespace Microsoft.FSharp.Collections
             checkNonNull "arrays" arrays
             match arrays with
             | :? ('T[][]) as ts -> ts |> transposeArrays // avoid a clone, since we only read the array
-            | _ -> arrays |> Seq.toArray |> transposeArrays
+            | _ -> arrays |> Microsoft.FSharp.Primitives.Basics.Array.ofSeq |> transposeArrays
 
         [<CompiledName("Truncate")>]
         let truncate count (array:'T[]) =

src/fsharp/FSharp.Core/collections.fs

@@ -48,3 +48,12 @@ namespace Microsoft.FSharp.Collections
             { new IComparer<'T> with
                   member __.Compare(x,y) = comparer.Invoke(x,y) } 
 
+    [<Struct; NoComparison; NoEquality>]
+    type internal StructBox<'T when 'T:equality>(value:'T) =
+        member x.Value = value
+        static member Comparer =
+            let gcomparer = HashIdentity.Structural<'T>
+            { new IEqualityComparer<StructBox<'T>> with
+                    member __.GetHashCode(v) = gcomparer.GetHashCode(v.Value)
+                    member __.Equals(v1,v2) = gcomparer.Equals(v1.Value,v2.Value) }
+

src/fsharp/FSharp.Core/collections.fsi

@@ -49,4 +49,8 @@ namespace Microsoft.FSharp.Collections
         // inline justification: allows inlining of hash functions 
         val inline FromFunctions<'T> : hasher:('T -> int) -> equality:('T -> 'T -> bool) -> IEqualityComparer<'T> 
 
-
+    [<Struct; NoComparison; NoEquality>]
+    type internal StructBox<'T when 'T : equality> = 
+        new : value:'T -> StructBox<'T>
+        member Value : 'T
+        static member Comparer : IEqualityComparer<StructBox<'T>>

src/fsharp/FSharp.Core/fslib-extra-pervasives.fs

@@ -134,7 +134,7 @@ module ExtraTopLevelOperators =
     let dictValueType (l:seq<'Key*'T>) = dictImpl HashIdentity.Structural<'Key> id id l
 
     // Wrap a StructBox around all keys in case the key type is itself a type using null as a representation
-    let dictRefType   (l:seq<'Key*'T>) = dictImpl RuntimeHelpers.StructBox<'Key>.Comparer (fun k -> RuntimeHelpers.StructBox k) (fun sb -> sb.Value) l
+    let dictRefType   (l:seq<'Key*'T>) = dictImpl StructBox<'Key>.Comparer (fun k -> StructBox k) (fun sb -> sb.Value) l
 
     [<CompiledName("CreateDictionary")>]
     let dict (keyValuePairs:seq<'Key*'T>) : IDictionary<'Key,'T> =