changed array types to postfix form in all signatures

src/FSharp.Core/Linq.fsi

@@ -78,14 +78,14 @@ module LeafExpressionConverter =
     /// </summary>
     ///
     /// <example-tbd></example-tbd>
-    val SubstHelper: Expr * Var[] * obj[] -> Expr<'T>
+    val SubstHelper: Expr * Var array * obj array -> Expr<'T>
 
     /// <summary>
     /// A runtime helper used to evaluate nested quotation literals.
     /// </summary>
     ///
     /// <example-tbd></example-tbd>
-    val SubstHelperRaw: Expr * Var[] * obj[] -> Expr
+    val SubstHelperRaw: Expr * Var array * obj array -> Expr
 
     val internal (|SpecificCallToMethod|_|):
         System.RuntimeMethodHandle -> (Expr -> (Expr option * Reflection.MethodInfo * Expr list) option)

src/FSharp.Core/async.fsi

@@ -428,7 +428,7 @@ namespace Microsoft.FSharp.Control
         /// </code>
         /// This will print "3", "5", "7", "11" (in any order) in 1-2 seconds and then [| false; true; true; true; false; true |].
         /// </example>
-        static member Parallel : computations:seq<Async<'T>> -> Async<'T[]>
+        static member Parallel : computations:seq<Async<'T>> -> Async<'T array>
 
         /// <summary>Creates an asynchronous computation that executes all the given asynchronous computations,
         /// initially queueing each as work items and using a fork/join pattern.</summary>
@@ -475,7 +475,7 @@ namespace Microsoft.FSharp.Control
         /// This will print "3", "5" (in any order) in 1-2 seconds, and then "7", "11" (in any order) in 1-2 more seconds and then
         /// [| false; true; true; true; false; true |].
         /// </example>
-        static member Parallel : computations:seq<Async<'T>> * ?maxDegreeOfParallelism : int -> Async<'T[]>
+        static member Parallel : computations:seq<Async<'T>> * ?maxDegreeOfParallelism : int -> Async<'T array>
 
         /// <summary>Creates an asynchronous computation that executes all the given asynchronous computations sequentially.</summary>
         ///
@@ -520,7 +520,7 @@ namespace Microsoft.FSharp.Control
         /// This will print "3", "5", "7", "11" with ~1-2 seconds between them except for pauses where even numbers would be and then
         /// prints [| false; true; true; true; false; true |].
         /// </example>
-        static member Sequential : computations:seq<Async<'T>> -> Async<'T[]>
+        static member Sequential : computations:seq<Async<'T>> -> Async<'T array>
 
         /// <summary>
         /// Creates an asynchronous computation that executes all given asynchronous computations in parallel, 
@@ -1409,17 +1409,17 @@ namespace Microsoft.FSharp.Control
             /// 
             /// <example-tbd></example-tbd>
             [<CompiledName("AsyncRead")>] // give the extension member a nice, unmangled compiled name, unique within this module
-            member AsyncRead : buffer:byte[] * ?offset:int * ?count:int -> Async<int>
+            member AsyncRead : buffer:byte array * ?offset:int * ?count:int -> Async<int>
 
             /// <summary>Returns an asynchronous computation that will read the given number of bytes from the stream.</summary>
             ///
             /// <param name="count">The number of bytes to read.</param>
             ///
-            /// <returns>An asynchronous computation that returns the read byte[] when run.</returns> 
+            /// <returns>An asynchronous computation that returns the read byte array when run.</returns> 
             /// 
             /// <example-tbd></example-tbd>
             [<CompiledName("AsyncReadBytes")>] // give the extension member a nice, unmangled compiled name, unique within this module
-            member AsyncRead : count:int -> Async<byte[]>
+            member AsyncRead : count:int -> Async<byte array>
 
             /// <summary>Returns an asynchronous computation that will write the given bytes to the stream.</summary>
             ///
@@ -1435,7 +1435,7 @@ namespace Microsoft.FSharp.Control
             /// 
             /// <example-tbd></example-tbd>
             [<CompiledName("AsyncWrite")>] // give the extension member a nice, unmangled compiled name, unique within this module
-            member AsyncWrite : buffer:byte[] * ?offset:int * ?count:int -> Async<unit>
+            member AsyncWrite : buffer:byte array * ?offset:int * ?count:int -> Async<unit>
 
 
         ///<summary>The family of first class event values for delegate types that satisfy the F# delegate constraint.</summary>
@@ -1522,7 +1522,7 @@ namespace Microsoft.FSharp.Control
             /// </example>
             /// Downloads the data in bytes and decodes it to a string.
             [<CompiledName("AsyncDownloadData")>] // give the extension member a nice, unmangled compiled name, unique within this module
-            member AsyncDownloadData : address:System.Uri -> Async<byte[]>
+            member AsyncDownloadData : address:System.Uri -> Async<byte array>
 
             /// <summary>Returns an asynchronous computation that, when run, will wait for the download of the given URI to specified file.</summary>
             ///

src/FSharp.Core/collections.fsi

@@ -70,7 +70,7 @@ module HashIdentity =
     /// <code>
     /// open System.Collections.Generic
     ///
-    /// let dict = new Dictionary&lt;int[],int&gt;(HashIdentity.Structural)
+    /// let dict = new Dictionary&lt;int array,int&gt;(HashIdentity.Structural)
     ///
     /// let arr1 = [| 1;2;3 |]
     /// let arr2 = [| 1;2;3 |]
@@ -134,7 +134,7 @@ module HashIdentity =
     /// <code>
     /// open System.Collections.Generic
     ///
-    /// let dict = new Dictionary&lt;int[],int&gt;(HashIdentity.Structural)
+    /// let dict = new Dictionary&lt;int array,int&gt;(HashIdentity.Structural)
     ///
     /// let arr1 = [| 1;2;3 |]
     /// let arr2 = [| 1;2;3 |]

src/FSharp.Core/event.fsi

@@ -23,7 +23,7 @@ type DelegateEvent<'Delegate when 'Delegate :> System.Delegate> =
     /// <param name="args">The parameters for the event.</param>
     ///
     /// <example-tbd></example-tbd>
-    member Trigger: args: obj[] -> unit
+    member Trigger: args: obj array -> unit
 
     /// <summary>Publishes the event as a first class event value.</summary>
     ///

src/FSharp.Core/fslib-extra-pervasives.fsi

@@ -459,7 +459,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         new :  systemRuntimeContainsType : (string -> bool) -> TypeProviderConfig
 
         /// Create a configuration which calls the given functions for the corresponding operation.
-        new :  systemRuntimeContainsType : (string -> bool) * getReferencedAssemblies : (unit -> string[]) -> TypeProviderConfig
+        new :  systemRuntimeContainsType : (string -> bool) * getReferencedAssemblies : (unit -> string array) -> TypeProviderConfig
 
         /// Get the full path to use to resolve relative paths in any file name arguments given to the type provider instance.
         member ResolutionFolder : string with get,set
@@ -468,7 +468,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         member RuntimeAssembly : string with get,set
 
         /// Get the referenced assemblies for the type provider instance.
-        member ReferencedAssemblies : string[] with get,set
+        member ReferencedAssemblies : string array with get,set
 
         /// Get the full path to use for temporary files for the type provider instance.
         member TemporaryFolder : string with get,set
@@ -493,13 +493,13 @@ namespace Microsoft.FSharp.Core.CompilerServices
         abstract NamespaceName : string
 
         /// The sub-namespaces in this namespace. An optional member to prevent generation of namespaces until an outer namespace is explored.
-        abstract GetNestedNamespaces : unit -> IProvidedNamespace[] 
+        abstract GetNestedNamespaces : unit -> IProvidedNamespace array 
 
         /// <summary>
         /// The top-level types
         /// </summary>
         /// <returns></returns>
-        abstract GetTypes : unit -> Type[] 
+        abstract GetTypes : unit -> Type array 
 
         /// <summary>
         /// Compilers call this method to query a type provider for a type <c>name</c>.
@@ -518,7 +518,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <summary>
         /// Gets the namespaces provided by the type provider.
         /// </summary>
-        abstract GetNamespaces : unit -> IProvidedNamespace[] 
+        abstract GetNamespaces : unit -> IProvidedNamespace array 
 
         /// <summary>
         /// Get the static parameters for a provided type. 
@@ -527,7 +527,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <param name="typeWithoutArguments">A type returned by GetTypes or ResolveTypeName</param>
         ///
         /// <returns></returns>
-        abstract GetStaticParameters : typeWithoutArguments:Type -> ParameterInfo[]
+        abstract GetStaticParameters : typeWithoutArguments:Type -> ParameterInfo array
 
         /// <summary>
         /// Apply static arguments to a provided type that accepts static arguments. 
@@ -540,7 +540,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <param name="staticArguments">the static parameters, indexed by name</param>
         ///
         /// <returns></returns>
-        abstract ApplyStaticArguments : typeWithoutArguments:Type * typePathWithArguments:string[] * staticArguments:obj[] -> Type 
+        abstract ApplyStaticArguments : typeWithoutArguments:Type * typePathWithArguments:string array * staticArguments:obj array -> Type 
 
         /// <summary>
         /// Called by the compiler to ask for an Expression tree to replace the given MethodBase with.
@@ -550,7 +550,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <param name="parameters">Expressions that represent the parameters to this call.</param>
         ///
         /// <returns>An expression that the compiler will use in place of the given method base.</returns>
-        abstract GetInvokerExpression : syntheticMethodBase:MethodBase * parameters:Expr[] -> Expr
+        abstract GetInvokerExpression : syntheticMethodBase:MethodBase * parameters:Expr array -> Expr
 
         /// <summary>
         /// Triggered when an assumption changes that invalidates the resolutions so far reported by the provider
@@ -561,7 +561,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <summary>
         /// Get the physical contents of the given logical provided assembly.
         /// </summary>
-        abstract GetGeneratedAssemblyContents : assembly:Assembly -> byte[]
+        abstract GetGeneratedAssemblyContents : assembly:Assembly -> byte array
 
     /// Represents additional, optional information for a type provider component
     type ITypeProvider2 =
@@ -573,7 +573,7 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <param name="methodWithoutArguments">A method returned by GetMethod on a provided type</param>
         ///
         /// <returns>The static parameters of the provided method, if any</returns>
-        abstract GetStaticParametersForMethod : methodWithoutArguments:MethodBase -> ParameterInfo[] 
+        abstract GetStaticParametersForMethod : methodWithoutArguments:MethodBase -> ParameterInfo array 
 
         /// <summary>
         /// Apply static arguments to a provided method that accepts static arguments. 
@@ -584,4 +584,4 @@ namespace Microsoft.FSharp.Core.CompilerServices
         /// <param name="staticArguments">the values of the static parameters, indexed by name</param>
         ///
         /// <returns>The provided method definition corresponding to the given static parameter values</returns>
-        abstract ApplyStaticArgumentsForMethod : methodWithoutArguments:MethodBase * methodNameWithArguments:string * staticArguments:obj[] -> MethodBase
+        abstract ApplyStaticArgumentsForMethod : methodWithoutArguments:MethodBase * methodNameWithArguments:string * staticArguments:obj array -> MethodBase

src/FSharp.Core/list.fsi

@@ -1594,7 +1594,7 @@ module List =
     /// Evaluates to <c>[ 1; 2; 5 ]</c>.
     /// </example>
     [<CompiledName("OfArray")>]
-    val ofArray : array:'T[] -> 'T list
+    val ofArray : array:'T array -> 'T list
 
     /// <summary>Builds a new list from the given enumerable object.</summary>
     ///
@@ -2176,7 +2176,7 @@ module List =
     /// Evaluates to <c>[| 1; 2; 5 |]</c>.
     /// </example>
     [<CompiledName("ToArray")>]
-    val toArray: list:'T list -> 'T[]
+    val toArray: list:'T list -> 'T array
 
     /// <summary>Views the given list as a sequence.</summary>
     ///

src/FSharp.Core/local.fsi

@@ -72,10 +72,10 @@ module internal List =
     val splitInto: int -> 'T list -> 'T list list
     val zip: 'T1 list -> 'T2 list -> ('T1 * 'T2) list
     val zip3: 'T1 list -> 'T2 list -> 'T3 list -> ('T1 * 'T2 * 'T3) list
-    val ofArray: 'T[] -> 'T list
+    val ofArray: 'T array -> 'T list
     val take: int -> 'T list -> 'T list
     val takeWhile: ('T -> bool) -> 'T list -> 'T list
-    val toArray: 'T list -> 'T[]
+    val toArray: 'T list -> 'T array
     val inline ofSeq: seq<'T> -> 'T List
     val splitAt: int -> 'T list -> ('T list * 'T list)
     val transpose: 'T list list -> 'T list list
@@ -84,40 +84,40 @@ module internal List =
 
 module internal Array =
     // The input parameter should be checked by callers if necessary
-    val inline zeroCreateUnchecked: int -> 'T[]
+    val inline zeroCreateUnchecked: int -> 'T array
 
-    val inline init: int -> (int -> 'T) -> 'T[]
+    val inline init: int -> (int -> 'T) -> 'T array
 
-    val splitInto: int -> 'T[] -> 'T[][]
+    val splitInto: int -> 'T array -> 'T array array
 
-    val findBack: predicate: ('T -> bool) -> array: 'T[] -> 'T
+    val findBack: predicate: ('T -> bool) -> array: 'T array -> 'T
 
-    val tryFindBack: predicate: ('T -> bool) -> array: 'T[] -> 'T option
+    val tryFindBack: predicate: ('T -> bool) -> array: 'T array -> 'T option
 
-    val findIndexBack: predicate: ('T -> bool) -> array: 'T[] -> int
+    val findIndexBack: predicate: ('T -> bool) -> array: 'T array -> int
 
-    val tryFindIndexBack: predicate: ('T -> bool) -> array: 'T[] -> int option
+    val tryFindIndexBack: predicate: ('T -> bool) -> array: 'T array -> int option
 
-    val mapFold: ('State -> 'T -> 'U * 'State) -> 'State -> 'T[] -> 'U[] * 'State
+    val mapFold: ('State -> 'T -> 'U * 'State) -> 'State -> 'T array -> 'U array * 'State
 
-    val mapFoldBack: ('T -> 'State -> 'U * 'State) -> 'T[] -> 'State -> 'U[] * 'State
+    val mapFoldBack: ('T -> 'State -> 'U * 'State) -> 'T array -> 'State -> 'U array * 'State
 
-    val permute: indexMap: (int -> int) -> 'T[] -> 'T[]
+    val permute: indexMap: (int -> int) -> 'T array -> 'T array
 
     val scanSubRight:
-        f: ('T -> 'State -> 'State) -> array: 'T[] -> start: int -> fin: int -> initState: 'State -> 'State[]
+        f: ('T -> 'State -> 'State) -> array: 'T array -> start: int -> fin: int -> initState: 'State -> 'State array
 
-    val inline subUnchecked: int -> int -> 'T[] -> 'T[]
+    val inline subUnchecked: int -> int -> 'T array -> 'T array
 
-    val unstableSortInPlaceBy: projection: ('T -> 'Key) -> array: 'T[] -> unit when 'Key: comparison
+    val unstableSortInPlaceBy: projection: ('T -> 'Key) -> array: 'T array -> unit when 'Key: comparison
 
-    val unstableSortInPlace: array: 'T[] -> unit when 'T: comparison
+    val unstableSortInPlace: array: 'T array -> unit when 'T: comparison
 
-    val stableSortInPlaceBy: projection: ('T -> 'Key) -> array: 'T[] -> unit when 'Key: comparison
+    val stableSortInPlaceBy: projection: ('T -> 'Key) -> array: 'T array -> unit when 'Key: comparison
 
-    val stableSortInPlaceWith: comparer: ('T -> 'T -> int) -> array: 'T[] -> unit
+    val stableSortInPlaceWith: comparer: ('T -> 'T -> int) -> array: 'T array -> unit
 
-    val stableSortInPlace: array: 'T[] -> unit when 'T: comparison
+    val stableSortInPlace: array: 'T array -> unit when 'T: comparison
 
 module internal Seq =
     val tryLastV: 'T seq -> 'T ValueOption

src/FSharp.Core/map.fsi

@@ -294,7 +294,7 @@ module Map =
     /// </code>
     /// </example>
     [<CompiledName("OfArray")>]
-    val ofArray: elements: ('Key * 'T)[] -> Map<'Key, 'T>
+    val ofArray: elements: ('Key * 'T) array -> Map<'Key, 'T>
 
     /// <summary>Returns a new map made from the given bindings.</summary>
     ///
@@ -361,7 +361,7 @@ module Map =
     /// </code>
     /// </example>
     [<CompiledName("ToArray")>]
-    val toArray: table: Map<'Key, 'T> -> ('Key * 'T)[]
+    val toArray: table: Map<'Key, 'T> -> ('Key * 'T) array
 
     /// <summary>Is the map empty?</summary>
     ///

src/FSharp.Core/option.fsi

@@ -380,7 +380,7 @@ module Option =
     /// </code>
     /// </example>
     [<CompiledName("ToArray")>]
-    val inline toArray: option: 'T option -> 'T[]
+    val inline toArray: option: 'T option -> 'T array
 
     /// <summary>Convert the option to a list of length 0 or 1.</summary>
     ///
@@ -828,7 +828,7 @@ module ValueOption =
     /// </code>
     /// </example>
     [<CompiledName("ToArray")>]
-    val inline toArray: voption: 'T voption -> 'T[]
+    val inline toArray: voption: 'T voption -> 'T array
 
     /// <summary>Convert the value option to a list of length 0 or 1.</summary>
     ///

src/FSharp.Core/prim-types-prelude.fsi

@@ -133,7 +133,7 @@ namespace Microsoft.FSharp.Core
     /// <category>Basic Types</category>
     type uint = uint32
 
-    /// <summary>Single dimensional, zero-based arrays, written <c>int[]</c>, <c>string[]</c> etc.</summary>
+    /// <summary>Single dimensional, zero-based arrays, written <c>int array</c>, <c>string array</c> etc.</summary>
     ///
     /// <remarks>Use the values in the <c>Array</c> module to manipulate values 
     /// of this type, or the notation <c>arr.[x]</c> to get/set array
@@ -396,7 +396,7 @@ namespace Microsoft.FSharp.Core
     type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]`` =
         (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #)
 
-    /// <summary>Single dimensional, zero-based arrays, written <c>int[]</c>, <c>string[]</c> etc.</summary>
+    /// <summary>Single dimensional, zero-based arrays, written <c>int array</c>, <c>string array</c> etc.</summary>
     /// 
     /// <remarks>Use the values in the <see cref="T:Microsoft.FSharp.Collections.ArrayModule" /> module to manipulate values 
     /// of this type, or the notation <c>arr.[x]</c> to get/set array