⚠️ Fix map(to:) name collision (#128)

Author: danshevluk

Sources/Operators/MapTo.swift renamed to Sources/Operators/MapToValue.swift

@@ -1,5 +1,5 @@
 //
-//  MapTo.swift
+//  MapToValue.swift
 //  CombineExt
 //
 //  Created by Dan Halliday on 08/05/2022.
@@ -14,8 +14,8 @@ public extension Publisher {
     /// Replace each upstream value with a constant.
     ///
     /// - Parameter value: The constant with which to replace each upstream value.
-    /// - Returns: A new publisher wrapping the upstream, but with output type `Result`.
-    func map<Result>(to value: Result) -> Publishers.Map<Self, Result> {
+    /// - Returns: A new publisher wrapping the upstream, but with output type `Value`.
+    func mapToValue<Value>(_ value: Value) -> Publishers.Map<Self, Value> {
         map { _ in value }
     }
 }

Tests/MapToTests.swift

@@ -0,0 +1,106 @@
+//
+//  MapToValueTests.swift
+//  CombineExt
+//
+//  Created by Dan Halliday on 08/05/2022.
+//  Copyright © 2022 Combine Community. All rights reserved.
+//
+
+import Foundation
+
+#if !os(watchOS)
+import XCTest
+import Combine
+import CombineExt
+
+@available(OSX 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
+final class MapToValueTests: XCTestCase {
+    private var subscription: AnyCancellable!
+
+    func testMapToConstantValue() {
+        let subject = PassthroughSubject<Int, Never>()
+        var result: Int? = nil
+
+        subscription = subject
+            .mapToValue(2)
+            .sink(receiveValue: { result = $0 })
+
+        subject.send(1)
+        XCTAssertEqual(result, 2)
+    }
+
+    func testMapToWithMultipleElements() {
+        let expectation = XCTestExpectation()
+        expectation.expectedFulfillmentCount = 3
+
+        let subject = PassthroughSubject<Int, Never>()
+
+        subscription = subject
+            .mapToValue("hello")
+            .sink { element in
+                XCTAssertEqual(element, "hello")
+                expectation.fulfill()
+            }
+
+        subject.send(1)
+        subject.send(2)
+        subject.send(1)
+
+        wait(for: [expectation], timeout: 3)
+    }
+
+    func testMapToVoidType() {
+        let expectation = XCTestExpectation()
+        let subject = PassthroughSubject<Int, Never>()
+
+        subscription = subject
+            .mapToValue(Void())
+            .sink { element in
+                XCTAssertTrue(type(of: element) == Void.self)
+
+                expectation.fulfill()
+            }
+
+        subject.send(1)
+
+        wait(for: [expectation], timeout: 3)
+    }
+
+    func testMapToOptionalType() {
+        let subject = PassthroughSubject<Int, Never>()
+        let value: String? = nil
+
+        var result: String? = nil
+
+        subscription = subject
+            .mapToValue(value)
+            .sink(receiveValue: { result = $0 })
+
+        subject.send(1)
+        XCTAssertEqual(result, nil)
+    }
+
+    /// Checks if regular map functions complies and works as expected.
+    func testMapNameCollision() {
+        let fooSubject = PassthroughSubject<Int, Never>()
+        let barSubject = PassthroughSubject<Int, Never>()
+
+        var result: String? = nil
+
+        let combinedPublisher = Publishers.CombineLatest(fooSubject, barSubject)
+            .map { fooItem, barItem in
+                fooItem * barItem
+            }
+
+        subscription = combinedPublisher
+            .map {
+                "\($0)"
+            }
+            .sink(receiveValue: { result = $0 })
+
+        fooSubject.send(5)
+        barSubject.send(6)
+        XCTAssertEqual(result, "30")
+    }
+}
+#endif