docs: start the comments of Arrays with the summaries of the FSharp.Core functions

The comment of each function of Arrays now begins with the summary of the function of the FSharp.Core Array module that
it mirrors, word for word (FSharp.Core 10.1, read from its documentation file), and the sentences after it say what
differs and why the function exists. The summary of Array.zip3 says "an array of pairs", which is a slip, so the comment
of zip3 says triples and notes the slip. NullableKey has no original and says so.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: xperiandri

src/FSharp.Collections.Immutable/Helper/Arrays.fs

@@ -8,15 +8,18 @@
 /// `structPair` or `structTriple` and the function of `Tuple.FlatList` with `referencePair` or `referenceTriple`, so
 /// that it exists once. For 10 000 elements, `zip` of struct tuples allocates 80 KB where `Array.zip` followed by a
 /// conversion allocates 400 KB.
+/// The first sentences of the comment of each function are the summary of the function of the FSharp.Core `Array` module
+/// word for word (FSharp.Core 10.1), and the sentences after them say what differs and why the function exists.
 module internal FSharp.Collections.Immutable.Arrays
 
 open System
 open System.Collections.Generic
 open System.Linq
 
-/// The pairs of every element of `array1` with every element of `array2`.
-/// It exists because `Array.allPairs` returns reference tuples. `FlatList.allPairs` builds struct tuples with it
-/// directly (720 KB for 300 by 300 elements, where `Array.allPairs` followed by a conversion allocates 3.6 MB).
+/// Returns a new array that contains all pairings of elements from the first and second arrays.
+/// The pairs are built with `tuple`. It exists because `Array.allPairs` returns reference tuples. `FlatList.allPairs`
+/// builds struct tuples with it directly (720 KB for 300 by 300 elements, where `Array.allPairs` followed by a conversion
+/// allocates 3.6 MB).
 let inline allPairs ([<InlineIfLambda>] tuple : 'T1 -> 'T2 -> 'R) (array1 : 'T1 array) (array2 : 'T2 array) : 'R array =
     let length2 = array2.Length
     let result = Array.zeroCreate (array1.Length * length2)
@@ -27,7 +30,7 @@ let inline allPairs ([<InlineIfLambda>] tuple : 'T1 -> 'T2 -> 'R) (array1 : 'T1
 
     result
 
-/// A key that may be null, for a dictionary, which rejects null keys.
+/// A key that may be null, for a dictionary, which rejects null keys. FSharp.Core has no such type in its public API.
 /// It exists because `Array.countBy` and `Array.groupBy` accept a null key (`[| null; "a"; null |]` has two keys), and
 /// `Dictionary` throws `ArgumentNullException` for one.
 [<Struct>]
@@ -45,9 +48,11 @@ let nullableKeyComparer<'Key when 'Key : equality> () =
             member _.GetHashCode key = structural.GetHashCode key.Key
     }
 
-/// The keys of the projection in the order of their first occurrence, each with the number of its elements.
-/// The counting keeps one counter per key, not the elements, so it needs memory for the keys only.
-/// It exists because `Array.countBy` returns reference tuples; null keys and keys that are arrays work as in FSharp.Core.
+/// Applies a key-generating function to each element of an array and returns an array yielding unique keys and their
+/// number of occurrences in the original array.
+/// The unique keys come in the order of their first occurrence, and the counting keeps one counter per key, not the
+/// elements, so it needs memory for the keys only. The tuples are built with `tuple`. It exists because `Array.countBy`
+/// returns reference tuples; null keys and keys that are arrays work as in FSharp.Core.
 let inline countBy
     ([<InlineIfLambda>] tuple : 'Key -> int -> 'R)
     (projection : 'T -> 'Key)
@@ -75,8 +80,11 @@ let inline countBy
 
     result
 
-/// The keys of the projection in the order of their first occurrence, each with its elements in their order.
-/// It exists because `Array.groupBy` returns reference tuples. It groups once with a lookup, as the project rules ask.
+/// Applies a key-generating function to each element of an array and yields an array of unique keys. Each unique key
+/// contains an array of all elements that match to this key.
+/// The keys come in the order of their first occurrence, and the elements of a key in their order. The tuples are built
+/// with `tuple`. It exists because `Array.groupBy` returns reference tuples. It groups once with a lookup, as the project
+/// rules ask.
 let inline groupBy
     ([<InlineIfLambda>] tuple : 'Key -> 'T array -> 'R)
     (projection : 'T -> 'Key)
@@ -92,8 +100,10 @@ let inline groupBy
 
     result
 
-/// Every element with its index.
-/// It exists because `Array.indexed` returns reference tuples (320 KB for 10 000 elements, where struct tuples take 80 KB).
+/// Builds a new array whose elements are the corresponding elements of the input array paired with the integer index
+/// (from 0) of each element.
+/// The pairs are built with `tuple`. It exists because `Array.indexed` returns reference tuples (320 KB for 10 000
+/// elements, where struct tuples take 80 KB).
 let inline indexed ([<InlineIfLambda>] tuple : int -> 'T -> 'R) (array : 'T array) : 'R array =
     let result = Array.zeroCreate array.Length
 
@@ -102,8 +112,10 @@ let inline indexed ([<InlineIfLambda>] tuple : int -> 'T -> 'R) (array : 'T arra
 
     result
 
-/// Every element with its successor.
-/// It exists because `Array.pairwise` returns reference tuples.
+/// Returns an array of each element in the input array paired with its predecessor, with the exception of the first
+/// element which is only returned as the predecessor of the second element. The predecessor comes first in the returned
+/// pairs.
+/// The pairs are built with `tuple`. It exists because `Array.pairwise` returns reference tuples.
 let inline pairwise ([<InlineIfLambda>] tuple : 'T -> 'T -> 'R) (array : 'T array) : 'R array =
     if array.Length < 2 then
         Array.Empty ()
@@ -115,10 +127,10 @@ let inline pairwise ([<InlineIfLambda>] tuple : 'T -> 'T -> 'R) (array : 'T arra
 
         result
 
-/// Splits the pairs of an array with `split` into two arrays.
-/// It exists because `Array.unzip` takes reference tuples. `FlatList.unzip` has struct tuples and passes `id` as `split`,
-/// `Tuple.FlatList.unzip` has reference tuples and converts one pair at a time, so that no array of converted pairs
-/// (400 KB for 10 000 pairs) is built.
+/// Splits an array of pairs into two arrays.
+/// `split` reads a pair as a struct tuple. It exists because `Array.unzip` takes reference tuples. `FlatList.unzip` has
+/// struct tuples and passes `id` as `split`, `Tuple.FlatList.unzip` has reference tuples and converts one pair at a time,
+/// so that no array of converted pairs (400 KB for 10 000 pairs) is built.
 let inline unzip ([<InlineIfLambda>] split : 'P -> struct ('T1 * 'T2)) (array : 'P array) =
     let result1 = Array.zeroCreate array.Length
     let result2 = Array.zeroCreate array.Length
@@ -130,8 +142,8 @@ let inline unzip ([<InlineIfLambda>] split : 'P -> struct ('T1 * 'T2)) (array :
 
     struct (result1, result2)
 
-/// Splits the triples of an array with `split` into three arrays.
-/// It exists for the reason of `unzip`: `Array.unzip3` takes reference tuples.
+/// Splits an array of triples into three arrays.
+/// `split` reads a triple as a struct tuple. It exists for the reason of `unzip`: `Array.unzip3` takes reference tuples.
 let inline unzip3 ([<InlineIfLambda>] split : 'P -> struct ('T1 * 'T2 * 'T3)) (array : 'P array) =
     let result1 = Array.zeroCreate array.Length
     let result2 = Array.zeroCreate array.Length
@@ -145,9 +157,10 @@ let inline unzip3 ([<InlineIfLambda>] split : 'P -> struct ('T1 * 'T2 * 'T3)) (a
 
     struct (result1, result2, result3)
 
-/// Pairs the elements of two arrays of the same length.
-/// It exists because `Array.zip` returns reference tuples (400 KB for 10 000 elements with the conversion, 80 KB here).
-/// The callers check the lengths first, with the exception of `Array.zip`.
+/// Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException
+/// is raised.
+/// The pairs are built with `tuple`, and the callers check the lengths first and raise the exception of `Array.zip`. It
+/// exists because `Array.zip` returns reference tuples (400 KB for 10 000 elements with the conversion, 80 KB here).
 let inline zip ([<InlineIfLambda>] tuple : 'T1 -> 'T2 -> 'R) (array1 : 'T1 array) (array2 : 'T2 array) : 'R array =
     let result = Array.zeroCreate array1.Length
 
@@ -156,8 +169,10 @@ let inline zip ([<InlineIfLambda>] tuple : 'T1 -> 'T2 -> 'R) (array1 : 'T1 array
 
     result
 
-/// Combines the elements of three arrays of the same length.
-/// It exists for the reason of `zip`: `Array.zip3` returns reference tuples. The callers check the lengths first.
+/// Combines three arrays into an array of triples. The three arrays must have equal lengths, otherwise an
+/// ArgumentException is raised. (The summary of `Array.zip3` says "an array of pairs", which is a slip.)
+/// The triples are built with `tuple`, and the callers check the lengths first. It exists for the reason of `zip`:
+/// `Array.zip3` returns reference tuples.
 let inline zip3
     ([<InlineIfLambda>] tuple : 'T1 -> 'T2 -> 'T3 -> 'R)
     (array1 : 'T1 array)