Refactor zips.

Author: lukeredpath

Sources/Coding/Decoding+Zips.swift

@@ -1,37 +1,11 @@
 import Foundation
 
-public func zip<A, B>(
-    _ a: Decoding<A>,
-    _ b: Decoding<B>
-) -> Decoding<(A, B)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder)
-        )
-    }
-}
-
-public func zip<A, B, Output>(
-    with f: @escaping (A, B) -> Output) -> (
-    Decoding<A>,
-    Decoding<B>
-) -> Decoding<Output> {
-    { zip($0, $1).map(f) }
-}
-
 public func zip<A, B, C>(
     _ a: Decoding<A>,
     _ b: Decoding<B>,
     _ c: Decoding<C>
 ) -> Decoding<(A, B, C)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c).map { ($0.0, $0.1, $1) }
 }
 
 public func zip<A, B, C, Output>(
@@ -49,14 +23,7 @@ public func zip<A, B, C, D>(
     _ c: Decoding<C>,
     _ d: Decoding<D>
 ) -> Decoding<(A, B, C, D)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder),
-            d.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c, d).map { ($0.0, $0.1, $1, $2) }
 }
 
 public func zip<A, B, C, D, Output>(
@@ -76,15 +43,7 @@ public func zip<A, B, C, D, E>(
     _ d: Decoding<D>,
     _ e: Decoding<E>
 ) -> Decoding<(A, B, C, D, E)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder),
-            d.decode(decoder),
-            e.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c, d, e).map { ($0.0, $0.1, $1, $2, $3) }
 }
 
 public func zip<A, B, C, D, E, Output>(
@@ -106,16 +65,7 @@ public func zip<A, B, C, D, E, F>(
     _ e: Decoding<E>,
     _ f: Decoding<F>
 ) -> Decoding<(A, B, C, D, E, F)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder),
-            d.decode(decoder),
-            e.decode(decoder),
-            f.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c, d, e, f).map { ($0.0, $0.1, $1, $2, $3, $4) }
 }
 
 public func zip<A, B, C, D, E, F, Output>(
@@ -139,17 +89,7 @@ public func zip<A, B, C, D, E, F, G>(
     _ f: Decoding<F>,
     _ g: Decoding<G>
 ) -> Decoding<(A, B, C, D, E, F, G)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder),
-            d.decode(decoder),
-            e.decode(decoder),
-            f.decode(decoder),
-            g.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c, d, e, f, g).map { ($0.0, $0.1, $1, $2, $3, $4, $5) }
 }
 
 public func zip<A, B, C, D, E, F, G, Output>(
@@ -175,18 +115,7 @@ public func zip<A, B, C, D, E, F, G, H>(
     _ g: Decoding<G>,
     _ h: Decoding<H>
 ) -> Decoding<(A, B, C, D, E, F, G, H)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder),
-            d.decode(decoder),
-            e.decode(decoder),
-            f.decode(decoder),
-            g.decode(decoder),
-            h.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c, d, e, f, g, h).map { ($0.0, $0.1, $1, $2, $3, $4, $5, $6) }
 }
 
 public func zip<A, B, C, D, E, F, G, H, Output>(
@@ -214,19 +143,7 @@ public func zip<A, B, C, D, E, F, G, H, I>(
     _ h: Decoding<H>,
     _ i: Decoding<I>
 ) -> Decoding<(A, B, C, D, E, F, G, H, I)> {
-    .init { decoder in
-        try (
-            a.decode(decoder),
-            b.decode(decoder),
-            c.decode(decoder),
-            d.decode(decoder),
-            e.decode(decoder),
-            f.decode(decoder),
-            g.decode(decoder),
-            h.decode(decoder),
-            i.decode(decoder)
-        )
-    }
+    zip(zip(a, b), c, d, e, f, g, h, i).map { ($0.0, $0.1, $1, $2, $3, $4, $5, $6, $7) }
 }
 
 public func zip<A, B, C, D, E, F, G, H, I, Output>(

Sources/Coding/Decoding.swift

@@ -341,3 +341,21 @@ public extension Decoding where Value: Decodable {
     }
 }
 
+// MARK: - Zip
+
+public func zip<A, B>(
+    _ a: Decoding<A>,
+    _ b: Decoding<B>
+) -> Decoding<(A, B)> {
+    .init { decoder in
+        try (a.decode(decoder), b.decode(decoder))
+    }
+}
+
+public func zip<A, B, Output>(
+    with f: @escaping (A, B) -> Output) -> (
+    Decoding<A>,
+    Decoding<B>
+) -> Decoding<Output> {
+    { zip($0, $1).map(f) }
+}