Add zipShortest to NonEmptyList and NonEmptySeq

Author: Rafal Gwozdzinski

src/FSharpPlus/Control/Collection.fs

@@ -439,10 +439,11 @@ type Intercalate =
 type ZipShortest =
     inherit Default1
 
-    static member ZipShortest ((x1: seq<'T1>        , x2: seq<'T2>        , _output: seq<'T1*'T2>),         _mthd: ZipShortest) = Seq.zipShortest x1 x2
-    static member ZipShortest ((x1: 'T1 []          , x2: 'T2 []          , _output: ('T1*'T2) []),         _mthd: ZipShortest) = Array.zipShortest x1 x2
-    static member ZipShortest ((x1: ResizeArray<'T1>, x2: ResizeArray<'T2>, _output: ResizeArray<'T1*'T2>), _mthd: ZipShortest) = ResizeArray.zipShortest x1 x2
-    static member ZipShortest ((x1: list<'T1>       , x2: list<'T2>       , _output: list<'T1*'T2>),        _mthd: ZipShortest) = List.zipShortest x1 x2
+    static member ZipShortest ((x1: seq<'T1>        , x2: seq<'T2>         , _output: seq<'T1*'T2>),         _mthd: ZipShortest) = Seq.zipShortest x1 x2
+    static member ZipShortest ((x1: 'T1 []          , x2: 'T2 []           , _output: ('T1*'T2) []),         _mthd: ZipShortest) = Array.zipShortest x1 x2
+    static member ZipShortest ((x1: ResizeArray<'T1>, x2: ResizeArray<'T2> , _output: ResizeArray<'T1*'T2>), _mthd: ZipShortest) = ResizeArray.zipShortest x1 x2
+    static member ZipShortest ((x1: list<'T1>       , x2: list<'T2>        , _output: list<'T1*'T2>),        _mthd: ZipShortest) = List.zipShortest x1 x2
+    static member ZipShortest ((x1: NonEmptySeq<'T1> , x2: NonEmptySeq<'T2>, _output: NonEmptySeq<'T1*'T2>), _mthd: ZipShortest) = NonEmptySeq.zipShortest x1 x2
 
     static member inline Invoke (source1: '``ZipShortestCollection<'T1>``) (source2: '``ZipShortestCollection<'T2>``) =
         let inline call_4 (a: ^a, b: ^b, c: ^c, d: ^d) = ((^a or ^b or ^c or ^d) : (static member ZipShortest : (_*_*_)*_ -> _) (b, c, d), a)
@@ -452,4 +453,8 @@ type ZipShortest =
     static member inline InvokeOnInstance (source1: '``ZipShortestCollection<'T1>``) (source2: '``ZipShortestCollection<'T2>``) : '``ZipShortestCollection<'T1 * 'T2>`` =
         ((^``ZipShortestCollection<'T1>`` or ^``ZipShortestCollection<'T2>`` or  ^``ZipShortestCollection<'T1 * 'T2>``) : (static member ZipShortest : _*_ -> _) source1, source2)
 
+type ZipShortest with    
+    static member inline ZipShortest ((_: ^t when ^t : null and ^t: struct, _: ^u when ^u : null and ^u: struct, _output: ^r when ^r : null and ^r: struct), _mthd: Default1) = id
+    static member inline ZipShortest ((x: '``ZipShortestCollection<'T1>``            , y: '``ZipShortestCollection<'T2>``            , _output: '``ZipShortestCollection<'T1 * 'T2>``      ), _mthd: Default1) = ZipShortest.InvokeOnInstance x y : '``ZipShortestCollection<'T1 * 'T2>``
+    
 #endif

src/FSharpPlus/Data/NonEmptyList.fs

@@ -98,6 +98,17 @@ module NonEmptyList =
     /// <param name="list2">The second input list.</param>
     /// <returns>A single list containing pairs of matching elements from the input lists.</returns>
     let zip (list1: NonEmptyList<'T>) (list2: NonEmptyList<'U>) = {Head = (list1.Head, list2.Head); Tail = List.zip list1.Tail list2.Tail}
+    
+    /// <summary>
+    /// Zip safely two lists. If one list is shorter, excess elements are discarded from the right end of the longer list. 
+    /// </summary>
+    /// <param name="a1">First input list.</param>
+    /// <param name="a2">Second input list.</param>
+    /// <returns>List with corresponding pairs of input lists.</returns>
+    let zipShortest (list1: NonEmptyList<'T>) (list2: NonEmptyList<'U>) =
+        { Head = (list1.Head, list2.Head); Tail = List.zipShortest list1.Tail list2.Tail }
+    
+    
     /// Returns a new NonEmptyList with the element added to the beginning.
     let cons e {Head = x; Tail = xs} = {Head = e ; Tail = x::xs}
     /// Returns the first element of a new non empty list. You can also use property nel.Head.
@@ -202,6 +213,9 @@ type NonEmptyList<'t> with
     [<EditorBrowsable(EditorBrowsableState.Never)>]
     static member Zip (x, y) = NonEmptyList.zip x y
 
+    [<EditorBrowsable(EditorBrowsableState.Never)>]
+    static member ZipShortest (x, y) = NonEmptyList.zipShortest x y
+    
     static member (>>=) ({Head = x; Tail = xs}, f: _->NonEmptyList<'b>) =
         let {Head = y; Tail = ys} = f x
         let ys' = List.collect (NonEmptyList.toList << f) xs

src/FSharpPlus/Data/NonEmptySeq.fs

@@ -464,6 +464,14 @@ module NonEmptySeq =
     /// <returns>The result sequence.</returns>
     let zip3 (source1: NonEmptySeq<_>) (source2: NonEmptySeq<_>) (source3: NonEmptySeq<_>) = Seq.zip3 source1 source2 source3 |> unsafeOfSeq
 
+    /// <summary>
+    /// Zip safely two sequences. If one sequence is shorter, excess elements are discarded from the right end of the longer sequence. 
+    /// </summary>
+    /// <param name="a1">First input sequence.</param>
+    /// <param name="a2">Second input sequence.</param>
+    /// <returns>Sequence with corresponding pairs of input sequences.</returns>
+    let zipShortest (source1: NonEmptySeq<_>) (source2: NonEmptySeq<_>) = Seq.zipShortest source1 source2 |> unsafeOfSeq
+    
     /// <summary>Applies the given function to each element of the NonEmptySequence and concatenates all the
     /// results.</summary>
     ///

tests/FSharpPlus.Tests/Data.fs

@@ -352,6 +352,11 @@ module NonEmptyList =
     [<Test>]
     let ``zip `` () =
         nonEmptyList |> NonEmptyList.zip nonEmptyList |> NonEmptyList.toList |> shoulSeqEqual [(1,1)]
+    
+    [<Test>]
+    let zipShortest () =
+        let nonEmptyList' = nonEmptyList |> NonEmptyList.cons 2
+        nonEmptyList |> NonEmptyList.zipShortest nonEmptyList' |> NonEmptyList.toList |> shoulSeqEqual [(2,1)]
 
     [<Test>]
     let ``get head from NonEmptyList`` () =

tests/FSharpPlus.Tests/General.fs

@@ -708,6 +708,14 @@ module Collections =
         CollectionAssert.AreEqual (ResizeArray [1,"a"; 2,"b"], e)
         Assert.IsInstanceOf<ResizeArray<int*string>> e
 
+        let nes = zipShortest (NonEmptySeq.ofList [1; 2]) (NonEmptySeq.ofList ["a"; "b"; "c"])
+        CollectionAssert.AreEqual (NonEmptySeq.ofList [1,"a"; 2,"b"], nes)
+        Assert.IsInstanceOf<neseq<int*string>> nes 
+        
+        let nel = zipShortest (NonEmptyList.ofList [1; 2]) (NonEmptyList.ofList ["a"; "b"; "c"])
+        CollectionAssert.AreEqual (NonEmptyList.ofList [1,"a"; 2,"b"], nel)
+        Assert.IsInstanceOf<nelist<int*string>> nel 
+        
 module Foldable =
 
     let foldables =