refactor: build the messages of the Raise module with interpolated strings

The exceptions no longer go through String.Format with a format string and an array of boxed values. Each message is an
interpolated string, and the helper that formatted the array is gone. A script called every function with 31 argument
combinations in six cultures (invariant, en-US, de-DE, sv-SE, ar-SA and fa-IR) before and after the change: the 186
messages are identical, the minus sign of sv-SE included, because a hole without a format specifier formats with the
current culture as String.Format does, as the messages of FSharp.Core do.

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

Author: xperiandri

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

@@ -9,65 +9,56 @@ module internal FSharp.Collections.Immutable.Raise
 open System
 open System.Collections.Generic
 
-let inline private invalidArgFormat (arg : string) (format : string) (paramArray : obj array) =
-    raise (ArgumentException (String.Format (format, paramArray), arg))
-
 /// The arrays of a function of two arrays have different lengths.
 let invalidArgDifferentArrayLength (arg1 : string) (len1 : int) (arg2 : string) (len2 : int) : 'T =
-    invalidArgFormat arg1 "{0}\n{1}.Length = {2}, {3}.Length = {4}" [|
-        ErrorStrings.ArraysHadDifferentLengths
-        arg1
-        len1
-        arg2
-        len2
-    |]
+    let message =
+        $"{ErrorStrings.ArraysHadDifferentLengths}\n{arg1}.Length = {len1}, {arg2}.Length = {len2}"
+
+    raise (ArgumentException (message, arg1))
 
 /// The lists of a function of two lists have different lengths; `diff` is how much shorter `arg1` is.
 let invalidArgDifferentListLength (arg1 : string) (arg2 : string) (diff : int) : 'T =
-    invalidArgFormat arg1 "{0}\n{1} is {2} {3} shorter than {4}" [|
-        ErrorStrings.ListsHadDifferentLengths
-        arg1
-        diff
-        (if diff = 1 then "element" else "elements")
-        arg2
-    |]
+    let elements = if diff = 1 then "element" else "elements"
+
+    let message =
+        $"{ErrorStrings.ListsHadDifferentLengths}\n{arg1} is {diff} {elements} shorter than {arg2}"
+
+    raise (ArgumentException (message, arg1))
 
 /// The arrays of a function of three arrays have different lengths.
 let invalidArg3ArraysDifferent (arg1 : string) (arg2 : string) (arg3 : string) (len1 : int) (len2 : int) (len3 : int) : 'T =
-    invalidArgFormat
-        (String.Concat [| arg1; ", "; arg2; ", "; arg3 |])
-        "{0}\n {1}.Length = {2}, {3}.Length = {4}, {5}.Length = {6}"
-        [| ErrorStrings.ArraysHadDifferentLengths; arg1; len1; arg2; len2; arg3; len3 |]
+    let message =
+        $"{ErrorStrings.ArraysHadDifferentLengths}\n {arg1}.Length = {len1}, {arg2}.Length = {len2}, {arg3}.Length = {len3}"
+
+    raise (ArgumentException (message, $"{arg1}, {arg2}, {arg3}"))
 
 /// The lists of a function of three lists have different lengths.
 let invalidArg3ListsDifferent (arg1 : string) (arg2 : string) (arg3 : string) (len1 : int) (len2 : int) (len3 : int) : 'T =
-    invalidArgFormat
-        (String.Concat [| arg1; ", "; arg2; ", "; arg3 |])
-        "{0}\n {1}.Length = {2}, {3}.Length = {4}, {5}.Length = {6}"
-        [| ErrorStrings.ListsHadDifferentLengths; arg1; len1; arg2; len2; arg3; len3 |]
+    let message =
+        $"{ErrorStrings.ListsHadDifferentLengths}\n {arg1}.Length = {len1}, {arg2}.Length = {len2}, {arg3}.Length = {len3}"
+
+    raise (ArgumentException (message, $"{arg1}, {arg2}, {arg3}"))
 
 /// A count or an index is negative.
 let invalidArgInputMustBeNonNegative (arg : string) (count : int) : 'T =
-    invalidArgFormat arg "{0}\n{1} = {2}" [| ErrorStrings.InputMustBeNonNegative; arg; count |]
+    raise (ArgumentException ($"{ErrorStrings.InputMustBeNonNegative}\n{arg} = {count}", arg))
 
 /// A size is not positive.
 let invalidArgInputMustBePositive (arg : string) (count : int) : 'T =
-    invalidArgFormat arg "{0}\n{1} = {2}" [| ErrorStrings.InputMustBePositive; arg; count |]
+    raise (ArgumentException ($"{ErrorStrings.InputMustBePositive}\n{arg} = {count}", arg))
 
 /// An index or a count is beyond a bound.
 let invalidArgOutOfRange (arg : string) (index : int) (text : string) (bound : int) : 'T =
-    let message =
-        String.Format ("{0}\n{1} = {2}, {3} = {4}", [| box ErrorStrings.OutOfRange; arg; index; text; bound |])
+    let message = $"{ErrorStrings.OutOfRange}\n{arg} = {index}, {text} = {bound}"
 
     raise (ArgumentOutOfRangeException (arg, message))
 
 /// A list is shorter than an index.
 let invalidOpListNotEnoughElements (index : int) : 'T =
+    let elements = if index = 1 then "element" else "elements"
+
     let message =
-        String.Format (
-            "{0}\nThe list was {1} {2} shorter than the index",
-            [| box ErrorStrings.NotEnoughElements; index; (if index = 1 then "element" else "elements") |]
-        )
+        $"{ErrorStrings.NotEnoughElements}\nThe list was {index} {elements} shorter than the index"
 
     raise (InvalidOperationException message)