Use nullArgCheck and pin signatures (#653)

Author: gusty

docsrc/tools/doclib.fs

@@ -4,7 +4,7 @@ module DocLib
 // Copyright 2010 Steffen Forkmann
 // Apache license
 
-
+#nowarn "49"
 open System.IO
 
 module String =

src/FSharpPlus/Extensions/Array.fs

@@ -33,9 +33,9 @@ module Array =
     /// <param name="value">The element to add</param>
     /// <param name="array">The array to add to</param>
     /// <returns>A new array with the element added to the beginning.</returns>
-    let cons value array =
+    let cons value (array: 'T []) =
     #if !NET45
-        raiseIfNull (nameof(array)) array
+        let array = nullArgCheck (nameof array) array
         Array.insertAt 0 value array
     #else
         raiseIfNull "array" array
@@ -46,10 +46,10 @@ module Array =
     /// <param name="array">The input array.</param>
     /// <returns>A tuple with the head and the tail of the original array.</returns>
     /// <exception cref="T:System.ArgumentException">Thrown when the input array is empty.</exception>
-    let uncons array =
+    let uncons (array: 'T []) =
     #if !NET45
-        raiseIfNull (nameof(array)) array
-        if Array.isEmpty array then invalidArg (nameof(array)) LanguagePrimitives.ErrorStrings.InputSequenceEmptyString
+        let array = nullArgCheck (nameof array) array
+        if Array.isEmpty array then invalidArg (nameof array) LanguagePrimitives.ErrorStrings.InputSequenceEmptyString
         else array[0], array[1..]
     #else
         raiseIfNull "array" array
@@ -68,50 +68,69 @@ module Array =
     /// val it : int [] = [|2; 4; 6; 3; 6; 9|]
     /// </code>
     /// </example>
-    let apply f x =
+    let apply (f: ('T -> 'U) []) (x: 'T []) : 'U [] =
         #if !NET45
-        raiseIfNull (nameof(x)) x
+        let x = nullArgCheck (nameof x) x
+        #else
+        raiseIfNull "x" x
         #endif
 
         let lenf, lenx = Array.length f, Array.length x
         Array.init (lenf * lenx) (fun i -> let (d, r) = Math.DivRem (i, lenx) in f.[d] x.[r])
 
-    /// Combines all values from the first array with the second, using the supplied mapping function.
-    let lift2 f x y =
+    /// <summary>Combines all values from three arrays and calls a mapping function on this combination.</summary>
+    /// <param name="mapping">Mapping function taking three element combination as input.</param>
+    /// <param name="array1">First array.</param>
+    /// <param name="array2">Second array.</param>
+    ///
+    /// <returns>Array with values returned from mapping function.</returns>
+    let lift2 (mapping: 'T1 -> 'T2 -> 'U) (array1: 'T1 []) (array2: 'T2 []) : 'U [] =
         #if !NET45
-        raiseIfNull (nameof(x)) x
-        raiseIfNull (nameof(y)) y
+        let array1 = nullArgCheck (nameof array1) array1
+        let array2 = nullArgCheck (nameof array2) array2
+        #else
+        raiseIfNull "array1" array1
+        raiseIfNull "array2" array2
         #endif
 
-        let lenx, leny = Array.length x, Array.length y
-        Array.init (lenx * leny) (fun i -> let (d, r) = Math.DivRem (i, leny) in f x.[d] y.[r])
+        let lenx, leny = Array.length array1, Array.length array2
+        Array.init (lenx * leny) (fun i -> let (d, r) = Math.DivRem (i, leny) in mapping array1.[d] array2.[r])
 
 
     /// <summary>Combines all values from three arrays and calls a mapping function on this combination.</summary>
     /// <param name="mapping">Mapping function taking three element combination as input.</param>
-    /// <param name="list1">First array.</param>
-    /// <param name="list2">Second array.</param>
-    /// <param name="list3">Third array.</param>
+    /// <param name="array1">First array.</param>
+    /// <param name="array2">Second array.</param>
+    /// <param name="array3">Third array.</param>
     ///
     /// <returns>Array with values returned from mapping function.</returns>
-    let lift3 mapping list1 list2 list3 =
+    let lift3 (mapping: 'T1 -> 'T2 -> 'T3 -> 'U) (array1: 'T1 []) (array2: 'T2 []) (array3: 'T3 []) : 'U [] =
         #if !NET45
-        raiseIfNull (nameof(list1)) list1
-        raiseIfNull (nameof(list2)) list2
-        raiseIfNull (nameof(list3)) list3
+        let array1 = nullArgCheck (nameof array1) array1
+        let array2 = nullArgCheck (nameof array2) array2
+        let array3 = nullArgCheck (nameof array3) array3
+        #else
+        raiseIfNull "array1" array1
+        raiseIfNull "array2" array2
+        raiseIfNull "array3" array3
         #endif
 
-        let lenx, leny, lenz = Array.length list1, Array.length list2, Array.length list3
-        let combinedFirstTwo = Array.init (lenx * leny) (fun i -> let (d, r) = Math.DivRem (i, leny) in (list1.[d], list2.[r]))
+        let lenx, leny, lenz = Array.length array1, Array.length array2, Array.length array3
+        let combinedFirstTwo = Array.init (lenx * leny) (fun i -> let (d, r) = Math.DivRem (i, leny) in (array1.[d], array2.[r]))
 
-        Array.init (lenx * leny * lenz) (fun i -> let (d, r) = Math.DivRem (i, lenz) in combinedFirstTwo.[d], list3.[r])
+        Array.init (lenx * leny * lenz) (fun i -> let (d, r) = Math.DivRem (i, lenz) in combinedFirstTwo.[d], array3.[r])
         |> Array.map (fun x -> mapping (fst (fst x)) (snd (fst x)) (snd x))
 
     /// Concatenates all elements, using the specified separator between each element.
-    let intercalate (separator: 'T []) (source: seq<'T []>) =
+    let intercalate (separator: 'T []) (source: seq<'T []>) : 'T [] =
         #if !NET45
-        raiseIfNull (nameof(source)) source
+        let separator = nullArgCheck (nameof separator) separator
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "separator" separator
+        raiseIfNull "source" source
         #endif
+
         #if FABLE_COMPILER || NET45
         source |> Seq.intercalate separator |> Seq.toArray
         #else
@@ -125,9 +144,11 @@ module Array =
         #endif
 
     /// Inserts a separator element between each element in the source array.
-    let intersperse element (source: 'T []) =
+    let intersperse element (source: 'T []) : 'T [] =
         #if !NET45
-        raiseIfNull (nameof(source)) source
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "source" source
         #endif
 
         match source with
@@ -140,20 +161,27 @@ module Array =
                 | _    ->  element)
 
     /// Creates a sequence of arrays by splitting the source array on any of the given separators.
-    let split (separators: seq<_ []>) (source: _ []) =
+    let split (separators: seq<'T []>) (source: 'T []) : seq<'T []> =
         #if !NET45
-        raiseIfNull (nameof(separators)) separators
-        raiseIfNull (nameof(source)) source
+        let separators = nullArgCheck (nameof separators) separators
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "separators" separators
+        raiseIfNull "source" source
         #endif
 
         source |> Array.toSeq |> Seq.split separators |> Seq.map Seq.toArray
 
     /// Replaces a subsequence of the source array with the given replacement array.
-    let replace (oldValue: 'T seq) (newValue: 'T seq) (source: 'T[]) : 'T[] =
+    let replace (oldValue: 'T []) (newValue: 'T []) (source: 'T[]) : 'T[] =
         #if !NET45
-        raiseIfNull (nameof(oldValue)) oldValue
-        raiseIfNull (nameof(newValue)) newValue
-        raiseIfNull (nameof(source)) source
+        let oldValue = nullArgCheck (nameof oldValue) oldValue
+        let newValue = nullArgCheck (nameof newValue) newValue
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "oldValue" oldValue
+        raiseIfNull "newValue" newValue
+        raiseIfNull "source" source
         #endif
         #if FABLE_COMPILER || NET45
         source |> Array.toSeq |> Seq.replace oldValue newValue |> Seq.toArray: 'T []
@@ -222,10 +250,13 @@ module Array =
     /// <returns>
     /// The index of the slice or <c>None</c>.
     /// </returns>
-    let findSliceIndex (slice: _ []) (source: _ []) =
+    let findSliceIndex (slice: 'T []) (source: 'T []) : int =
         #if !NET45
-        raiseIfNull (nameof(slice)) slice
-        raiseIfNull (nameof(source)) source
+        let slice = nullArgCheck (nameof slice) slice
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "slice" slice
+        raiseIfNull "source" source
         #endif
 
         let index = Internals.FindSliceIndex.arrayImpl slice source
@@ -241,10 +272,13 @@ module Array =
     /// <returns>
     /// The index of the slice or <c>None</c>.
     /// </returns>
-    let tryFindSliceIndex (slice: _ []) (source: _ []) =
+    let tryFindSliceIndex (slice: 'T []) (source: 'T []) : int option =
         #if !NET45
-        raiseIfNull (nameof(slice)) slice
-        raiseIfNull (nameof(source)) source
+        let slice = nullArgCheck (nameof slice) slice
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "slice" slice
+        raiseIfNull "source" source
         #endif
 
         let index = Internals.FindSliceIndex.arrayImpl slice source
@@ -257,10 +291,13 @@ module Array =
     /// <returns>
     /// The index of the slice or <c>None</c>.
     /// </returns>
-    let findLastSliceIndex (slice: _ []) (source: _ []) =
+    let findLastSliceIndex (slice: _ []) (source: _ []) : int =
         #if !NET45
-        raiseIfNull (nameof(slice)) slice
-        raiseIfNull (nameof(source)) source
+        let slice = nullArgCheck (nameof slice) slice
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "slice" slice
+        raiseIfNull "source" source
         #endif
 
         let index = Internals.FindLastSliceIndex.arrayImpl slice source
@@ -276,10 +313,13 @@ module Array =
     /// <returns>
     /// The index of the slice or <c>None</c>.
     /// </returns>
-    let tryFindLastSliceIndex (slice: _ []) (source: _ []) =
+    let tryFindLastSliceIndex (slice: 'T []) (source: 'T []) : int option =
         #if !NET45
-        raiseIfNull (nameof(slice)) slice
-        raiseIfNull (nameof(source)) source
+        let slice = nullArgCheck (nameof slice) slice
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "slice" slice
+        raiseIfNull "source" source
         #endif
 
         let index = Internals.FindLastSliceIndex.arrayImpl slice source
@@ -293,9 +333,11 @@ module Array =
     /// <returns>
     /// A tuple with both resulting arrays.
     /// </returns>
-    let partitionMap (mapper: 'T -> Choice<'T1,'T2>) (source: array<'T>) =
+    let partitionMap (mapper: 'T -> Choice<'T1, 'T2>) (source: array<'T>) : array<'T1> * array<'T2> =
         #if !NET45
-        raiseIfNull (nameof(source)) source
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "source" source
         #endif
 
         let (x, y) = ResizeArray (), ResizeArray ()
@@ -305,22 +347,29 @@ module Array =
     /// <summary>Safely build a new array whose elements are the results of applying the given function
     /// to each of the elements of the two arrays pairwise.</summary>
     /// <remark>If one array is shorter, excess elements are discarded from the right end of the longer array.</remark>
-    let map2Shortest f (a1: 'T []) (a2: 'U []) =
+    let map2Shortest (f: 'T1 -> 'T2 -> 'U) (a1: 'T1 []) (a2: 'T2 []) : 'U [] =
         #if !NET45
-        raiseIfNull (nameof(a1)) a1
-        raiseIfNull (nameof(a2)) a2
+        let a1 = nullArgCheck (nameof a1) a1
+        let a2 = nullArgCheck (nameof a2) a2
+        #else
+        raiseIfNull "a1" a1
+        raiseIfNull "a2" a2
         #endif
 
         Array.init (min a1.Length a2.Length) (fun i -> f a1.[i] a2.[i])
 
     /// <summary>Safely build a new array whose elements are the results of applying the given function
     /// to each of the elements of the three arrays pairwise.</summary>
     /// <remark>If one array is shorter, excess elements are discarded from the right end of the longer array.</remark>
-    let map3Shortest f (a1: 'T1 []) (a2: 'T2 []) (a3: 'T3 []) =
+    let map3Shortest (f: 'T1 -> 'T2 -> 'T3 -> 'U) (a1: 'T1 []) (a2: 'T2 []) (a3: 'T3 []) : 'U [] =
         #if !NET45
-        raiseIfNull (nameof a1) a1
-        raiseIfNull (nameof a2) a2
-        raiseIfNull (nameof a3) a3
+        let a1 = nullArgCheck (nameof a1) a1
+        let a2 = nullArgCheck (nameof a2) a2
+        let a3 = nullArgCheck (nameof a3) a3
+        #else
+        raiseIfNull "a1" a1
+        raiseIfNull "a2" a2
+        raiseIfNull "a3" a3
         #endif
         Array.init (min a1.Length a2.Length |> min a3.Length) (fun i -> f a1.[i] a2.[i] a3.[i])
 
@@ -330,10 +379,13 @@ module Array =
     /// <param name="a1">First input array.</param>
     /// <param name="a2">Second input array.</param>
     /// <returns>Array with corresponding pairs of input arrays.</returns>
-    let zipShortest (a1: array<'T1>) (a2: array<'T2>) =
+    let zipShortest (a1: array<'T1>) (a2: array<'T2>) : array<'T1 * 'T2> =
         #if !NET45
-        raiseIfNull (nameof(a1)) a1
-        raiseIfNull (nameof(a2)) a2
+        let a1 = nullArgCheck (nameof a1) a1
+        let a2 = nullArgCheck (nameof a2) a2
+        #else
+        raiseIfNull "a1" a1
+        raiseIfNull "a2" a2
         #endif
 
         Array.init (min a1.Length a2.Length) (fun i -> a1.[i], a2.[i])
@@ -345,11 +397,15 @@ module Array =
     /// <param name="a2">Second input array.</param>
     /// <param name="a3">Third input array.</param>
     /// <returns>Array with corresponding tuple of input arrays.</returns>
-    let zip3Shortest (a1: array<'T1>) (a2: array<'T2>) (a3: array<'T3>) =
+    let zip3Shortest (a1: array<'T1>) (a2: array<'T2>) (a3: array<'T3>) : array<'T1 * 'T2 * 'T3> =
         #if !NET45
-        raiseIfNull (nameof a1) a1
-        raiseIfNull (nameof a2) a2
-        raiseIfNull (nameof a3) a3
+        let a1 = nullArgCheck (nameof a1) a1
+        let a2 = nullArgCheck (nameof a2) a2
+        let a3 = nullArgCheck (nameof a3) a3
+        #else
+        raiseIfNull "a1" a1
+        raiseIfNull "a2" a2
+        raiseIfNull "a3" a3
         #endif
         Array.init (min a1.Length a2.Length |> min a3.Length) (fun i -> a1.[i], a2.[i], a3.[i])
 
@@ -358,9 +414,11 @@ module Array =
     /// <param name="source">The input array.</param>
     ///
     /// <returns>Array with values x for each Array value where the function returns Some(x).</returns>
-    let choosei mapping source =
+    let choosei (mapping: int -> 'T -> 'U option) (source: array<'T>) : array<'U> =
         #if !NET45
-        raiseIfNull (nameof(source)) source
+        let source = nullArgCheck (nameof source) source
+        #else
+        raiseIfNull "source" source
         #endif
 
         let mutable i = ref -1

src/FSharpPlus/Extensions/Enumerator.fs

@@ -1,5 +1,6 @@
 namespace FSharpPlus
 
+#nowarn "3261" // nullness checks
 #if (!FABLE_COMPILER || FABLE_COMPILER_3) && !FABLE_COMPILER_4
 
 /// Additional operations on IEnumerator

src/FSharpPlus/Extensions/Exception.fs

@@ -12,7 +12,7 @@ module Exception =
     /// Throws the given exception with its original stacktrace.
     let inline rethrow<'T> (exn: exn) =
         #if !NET45
-        raiseIfNull (nameof exn) exn
+        let exn = nullArgCheck (nameof exn) exn
         #endif
         (ExceptionDispatchInfo.Capture exn).Throw ()
         Unchecked.defaultof<'T>    
@@ -21,8 +21,8 @@ module Exception =
     /// Exceptions already present in the first argument won't be added.
     let add (exn1: exn) (exn2: exn) =
         #if !NET45
-        raiseIfNull (nameof exn1) exn1
-        raiseIfNull (nameof exn2) exn2
+        let exn1 = nullArgCheck (nameof exn1) exn1
+        let exn2 = nullArgCheck (nameof exn2) exn2
         #endif
         let f (e: exn) =
             match e with