fixup! feat: HashSet and ISet modules with the vocabulary of the FSharp.Core Set module

Every `seq<'T>` parameter rejects `null` and a default flat list that is given as a sequence
with an `ArgumentNullException` that names the parameter of our function (ADR 0001, D6). A
default flat list is a boxed, non-null struct, so the check for `null` alone let it reach the
BCL call, which failed with `InvalidOperationException` when it enumerated the sequence.

- `HashSet.ofSeq` and the member `ofSeq` of `CustomComparerHashSet` (`elements`), `addRange`
  and `removeRange` of `HashSet` and `ISet` (`elements`), and `intersectMany` and `unionMany`
  of `HashSet` and `ISet` (`sets`) call `checkNotNullOrDefaultSeq` first. The check of each set
  of `sets` stays. `ofList` and `ofArray` take another type and keep their check for `null`.
- The `yield!` overloads of `hashSet { }` for a sequence, an array and a hash set (`items`) and
  its `for` (`source`) check their input before the buffer is returned. A `null` array or hash
  set reached `UnionWith`, so the exception named `other`, and a `null` source made `for` throw
  `NullReferenceException`.
- The exception documentation of the affected functions says "null or a default flat list", as
  the documentation of `FlatList` does.

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

Author: xperiandri

src/FSharp.Collections.Immutable/HashSet/HashSet.CustomComparer.fs

@@ -46,7 +46,8 @@ type CustomComparerHashSet<'T> =
 
     [<CompiledName "OfSeq">]
     member this.ofSeq (elements : seq<'T>) : HashSet<'T> =
-        checkNotNull (nameof elements) elements
+        // A default flat list given as a sequence would fail with InvalidOperationException in the BCL call (ADR 0001, D6)
+        checkNotNullOrDefaultSeq (nameof elements) elements
         // A hash set gets the comparer through WithComparer, which returns the hash set itself for the same comparer
         // instance (the test is reference equality, ADR 0001, D14)
         ImmutableHashSet.CreateRange<'T>(this.Comparer, elements)

src/FSharp.Collections.Immutable/HashSet/HashSet.CustomComparer.fsi

@@ -102,7 +102,7 @@ type CustomComparerHashSet<'T> =
     /// The hash set of the elements that are distinct in the comparer; of the elements that the comparer considers equal,
     /// it holds the first one.
     /// </returns>
-    /// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/>.</exception>
+    /// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/> or a default flat list.</exception>
     /// <remarks>
     /// <para>
     /// O(n log n). The member wraps

src/FSharp.Collections.Immutable/HashSet/HashSet.fs

@@ -190,7 +190,7 @@ let add (value : 'T) (set : HashSet<'T>) =
 
 [<CompiledName "AddRange">]
 let addRange (elements : seq<'T>) (set : HashSet<'T>) =
-    checkNotNull (nameof elements) elements
+    checkNotNullOrDefaultSeq (nameof elements) elements
     checkNotNull (nameof set) set
     let result = set.Union elements
 
@@ -235,7 +235,7 @@ let intersect (set1 : HashSet<'T>) (set2 : HashSet<'T>) =
 [<CompiledName "IntersectMany">]
 let intersectMany (sets : seq<HashSet<'T>>) =
     // Set.intersectMany is Seq.reduce over Set.intersect, so its checks are those of Seq.reduce
-    checkNotNull (nameof sets) sets
+    checkNotNullOrDefaultSeq (nameof sets) sets
 
     // The type of a set is annotated, because the sequence that fixes it comes last
     let checkSet (set : HashSet<'T>) = checkNotNull (nameof sets) set
@@ -256,7 +256,7 @@ let remove (value : 'T) (set : HashSet<'T>) =
 
 [<CompiledName "RemoveRange">]
 let removeRange (elements : seq<'T>) (set : HashSet<'T>) =
-    checkNotNull (nameof elements) elements
+    checkNotNullOrDefaultSeq (nameof elements) elements
     checkNotNull (nameof set) set
     set.Except elements
 
@@ -274,7 +274,7 @@ let union (set1 : HashSet<'T>) (set2 : HashSet<'T>) =
 
 [<CompiledName "UnionMany">]
 let unionMany (sets : seq<HashSet<'T>>) =
-    checkNotNull (nameof sets) sets
+    checkNotNullOrDefaultSeq (nameof sets) sets
 
     let checkSet (set : HashSet<'T>) = checkNotNull (nameof sets) set
 

src/FSharp.Collections.Immutable/HashSet/HashSet.fsi

@@ -123,7 +123,7 @@ val ofReadOnlySpan : span : ReadOnlySpan<'T> -> HashSet<'T>
 /// </summary>
 /// <param name="elements">The input sequence.</param>
 /// <returns>The hash set of the distinct elements of the sequence.</returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/> or a default flat list.</exception>
 /// <remarks>
 /// O(n log n), or O(1) for a hash set that compares with the default comparer: the function returns such a hash set
 /// without a copy, and gives a hash set with another comparer the default one. The function wraps
@@ -438,7 +438,7 @@ val add : value : 'T -> set : HashSet<'T> -> HashSet<'T>
 /// A hash set of the elements and the elements of the sequence, with the comparer of the input; the input itself when the
 /// sequence adds no element.
 /// </returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> or <paramref name="set"/> is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/> or a default flat list, or <paramref name="set"/> is <see langword="null"/>.</exception>
 /// <remarks>
 /// <para>
 /// O(m log (n + m)), where n and m are the numbers of elements of the hash set and the sequence. The function wraps
@@ -526,7 +526,7 @@ val intersect : set1 : HashSet<'T> -> set2 : HashSet<'T> -> HashSet<'T>
 /// </summary>
 /// <param name="sets">The hash sets.</param>
 /// <returns>The intersection, with the comparer of the first hash set.</returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> or one of its hash sets is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> is <see langword="null"/> or a default flat list, or one of its hash sets is <see langword="null"/>.</exception>
 /// <exception cref="T:System.ArgumentException">Thrown when the sequence is empty.</exception>
 /// <remarks>
 /// O(N log n), where N is the total number of elements of the other hash sets and n the number of elements of the first
@@ -573,7 +573,7 @@ val remove : value : 'T -> set : HashSet<'T> -> HashSet<'T>
 /// A hash set of the other elements, with the comparer of the input; the input itself when it has no element equal to an
 /// element of the sequence.
 /// </returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> or <paramref name="set"/> is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/> or a default flat list, or <paramref name="set"/> is <see langword="null"/>.</exception>
 /// <remarks>
 /// O(m log n), where n and m are the numbers of elements of the hash set and the sequence. The function wraps
 /// <see cref="M:System.Collections.Immutable.ImmutableHashSet`1.Except(System.Collections.Generic.IEnumerable{`0})"/>
@@ -620,7 +620,7 @@ val union : set1 : HashSet<'T> -> set2 : HashSet<'T> -> HashSet<'T>
 /// The union, with the comparer of the first hash set; the empty hash set with the default comparer for an empty
 /// sequence.
 /// </returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> or one of its hash sets is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> is <see langword="null"/> or a default flat list, or one of its hash sets is <see langword="null"/>.</exception>
 /// <remarks>
 /// O(N log N), where N is the total number of elements of the hash sets. The function unites the hash sets from the first
 /// one to the last one.

src/FSharp.Collections.Immutable/HashSet/HashSetCE.fs

@@ -18,11 +18,20 @@ type HashSetCE<'T> (comparer : System.Collections.Generic.IEqualityComparer<'T>)
 
     member inline _.Yield (item : 'T) : HashSetBuffer<'T> = fun builder -> builder.Add item |> ignore
 
-    member inline _.YieldFrom (items : seq<'T>) : HashSetBuffer<'T> = fun builder -> builder.UnionWith items
+    // Each input is checked before the buffer is returned, so that the exception names the parameter of the expression and
+    // not the parameter of UnionWith (other); a default flat list given as a sequence is rejected as FlatListCE rejects it
+    // (ADR 0001, D6)
+    member inline _.YieldFrom (items : seq<'T>) : HashSetBuffer<'T> =
+        checkNotNullOrDefaultSeq (nameof items) items
+        fun builder -> builder.UnionWith items
 
-    member inline _.YieldFrom (items : 'T array) : HashSetBuffer<'T> = fun builder -> builder.UnionWith items
+    member inline _.YieldFrom (items : 'T array) : HashSetBuffer<'T> =
+        checkNotNull (nameof items) items
+        fun builder -> builder.UnionWith items
 
-    member inline _.YieldFrom (items : HashSet<'T>) : HashSetBuffer<'T> = fun builder -> builder.UnionWith items
+    member inline _.YieldFrom (items : HashSet<'T>) : HashSetBuffer<'T> =
+        checkNotNull (nameof items) items
+        fun builder -> builder.UnionWith items
 
     member inline _.YieldFrom (buffer : HashSetBuffer<'T>) : HashSetBuffer<'T> = buffer
 
@@ -35,6 +44,10 @@ type HashSetCE<'T> (comparer : System.Collections.Generic.IEqualityComparer<'T>)
         fun builder -> delayed () builder
 
     member inline _.For (source : seq<'U>, [<InlineIfLambda>] body : 'U -> HashSetBuffer<'T>) : HashSetBuffer<'T> =
+        // A null source would throw NullReferenceException and a default flat list InvalidOperationException when the loop
+        // enumerates; the expression rejects both as yield! does
+        checkNotNullOrDefaultSeq (nameof source) source
+
         fun builder ->
             for item in source do
                 body item builder

src/FSharp.Collections.Immutable/HashSet/HashSetCE.fsi

@@ -40,12 +40,15 @@ type HashSetCE<'T> =
     member inline Yield : item : 'T -> HashSetBuffer<'T>
 
     /// <summary>Adds the elements of a sequence.</summary>
+    /// <exception cref="T:System.ArgumentNullException">Thrown when the sequence is <see langword="null"/> or a default flat list.</exception>
     member inline YieldFrom : items : seq<'T> -> HashSetBuffer<'T>
 
     /// <summary>Adds the elements of an array.</summary>
+    /// <exception cref="T:System.ArgumentNullException">Thrown when the array is <see langword="null"/>.</exception>
     member inline YieldFrom : items : 'T array -> HashSetBuffer<'T>
 
     /// <summary>Adds the elements of a hash set.</summary>
+    /// <exception cref="T:System.ArgumentNullException">Thrown when the hash set is <see langword="null"/>.</exception>
     member inline YieldFrom : items : HashSet<'T> -> HashSetBuffer<'T>
 
     /// <summary>Adds the elements of another expression body.</summary>
@@ -60,6 +63,7 @@ type HashSetCE<'T> =
     member inline Delay : [<InlineIfLambda>] delayed : (unit -> HashSetBuffer<'T>) -> HashSetBuffer<'T>
 
     /// <summary>Adds the elements of the body for each item of a sequence.</summary>
+    /// <exception cref="T:System.ArgumentNullException">Thrown when the sequence is <see langword="null"/> or a default flat list.</exception>
     member inline For : source : seq<'U> * [<InlineIfLambda>] body : ('U -> HashSetBuffer<'T>) -> HashSetBuffer<'T>
 
     /// <summary>Adds the elements of the body while the guard holds.</summary>

src/FSharp.Collections.Immutable/HashSet/ISet.fs

@@ -103,7 +103,7 @@ let add (value : 'T) (set : IImmutableSet<'T>) =
 
 [<CompiledName "AddRange">]
 let addRange (elements : seq<'T>) (set : IImmutableSet<'T>) =
-    checkNotNull (nameof elements) elements
+    checkNotNullOrDefaultSeq (nameof elements) elements
     checkNotNull (nameof set) set
     let result = set.Union elements
 
@@ -145,7 +145,7 @@ let intersect (set1 : IImmutableSet<'T>) (set2 : IImmutableSet<'T>) =
 [<CompiledName "IntersectMany">]
 let intersectMany (sets : seq<IImmutableSet<'T>>) =
     // Set.intersectMany is Seq.reduce over Set.intersect, so its checks are those of Seq.reduce
-    checkNotNull (nameof sets) sets
+    checkNotNullOrDefaultSeq (nameof sets) sets
 
     // The type of a set is annotated, because the sequence that fixes it comes last
     let checkSet (set : IImmutableSet<'T>) = checkNotNull (nameof sets) set
@@ -166,7 +166,7 @@ let remove (value : 'T) (set : IImmutableSet<'T>) =
 
 [<CompiledName "RemoveRange">]
 let removeRange (elements : seq<'T>) (set : IImmutableSet<'T>) =
-    checkNotNull (nameof elements) elements
+    checkNotNullOrDefaultSeq (nameof elements) elements
     checkNotNull (nameof set) set
     // ImmutableHashSet and ImmutableSortedSet return the input itself when nothing is removed (ADR 0001, D14), so unlike
     // in addRange no check of the result is needed
@@ -186,7 +186,7 @@ let union (set1 : IImmutableSet<'T>) (set2 : IImmutableSet<'T>) =
 
 [<CompiledName "UnionMany">]
 let unionMany (sets : seq<IImmutableSet<'T>>) =
-    checkNotNull (nameof sets) sets
+    checkNotNullOrDefaultSeq (nameof sets) sets
 
     let checkSet (set : IImmutableSet<'T>) = checkNotNull (nameof sets) set
 

src/FSharp.Collections.Immutable/HashSet/ISet.fsi

@@ -260,7 +260,7 @@ val add : value : 'T -> set : IImmutableSet<'T> -> IImmutableSet<'T>
 /// A set of the elements and the elements of the sequence, with the implementation and the comparer of the input; the
 /// input itself when the sequence adds no element.
 /// </returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> or <paramref name="set"/> is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/> or a default flat list, or <paramref name="set"/> is <see langword="null"/>.</exception>
 /// <remarks>
 /// <para>
 /// The complexity depends on the implementation of the set: O(m log (n + m)) for an
@@ -360,7 +360,7 @@ val intersect : set1 : IImmutableSet<'T> -> set2 : IImmutableSet<'T> -> IImmutab
 /// </summary>
 /// <param name="sets">The sets.</param>
 /// <returns>The intersection, with the implementation and the comparer of the first set.</returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> or one of its sets is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> is <see langword="null"/> or a default flat list, or one of its sets is <see langword="null"/>.</exception>
 /// <exception cref="T:System.ArgumentException">Thrown when the sequence is empty.</exception>
 /// <remarks>
 /// The complexity depends on the implementation of the first set: O(N log n) for an
@@ -406,7 +406,7 @@ val remove : value : 'T -> set : IImmutableSet<'T> -> IImmutableSet<'T>
 /// A set of the other elements, with the implementation and the comparer of the input; the input itself when it has no
 /// element equal to an element of the sequence.
 /// </returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> or <paramref name="set"/> is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="elements"/> is <see langword="null"/> or a default flat list, or <paramref name="set"/> is <see langword="null"/>.</exception>
 /// <remarks>
 /// <para>
 /// The complexity depends on the implementation of the set: O(m log n) for an
@@ -465,7 +465,7 @@ val union : set1 : IImmutableSet<'T> -> set2 : IImmutableSet<'T> -> IImmutableSe
 /// <see cref="T:FSharp.Collections.Immutable.HashSet`1"/>, which compares with
 /// <see cref="P:System.Collections.Generic.EqualityComparer`1.Default"/>.
 /// </returns>
-/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> or one of its sets is <see langword="null"/>.</exception>
+/// <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="sets"/> is <see langword="null"/> or a default flat list, or one of its sets is <see langword="null"/>.</exception>
 /// <remarks>
 /// The complexity depends on the implementation of the first set: O(N log N) for an
 /// <see cref="T:System.Collections.Immutable.ImmutableHashSet`1"/>, where N is the total number of elements of the sets.