# map(_:) Creates an asynchronous sequence that maps the given error-throwing closure over the asynchronous sequence’s elements. ``` @preconcurrency func map(_ transform: @escaping @Sendable (Self.Element) async throws -> Transformed) -> AsyncThrowingMapSequence ``` ## Parameters `transform` A mapping closure. `transform` accepts an element of this sequence as its parameter and returns a transformed value of the same or of a different type. `transform` can also throw an error, which ends the transformed sequence. ## Return Value An asynchronous sequence that contains, in order, the elements produced by the `transform` closure. ## Discussion Use the `map(_:)` method to transform every element received from a base asynchronous sequence. Typically, you use this to transform from one type of element to another. In this example, an asynchronous sequence called `Counter` produces `Int` values from `1` to `5`. The closure provided to the `map(_:)` method takes each `Int` and looks up a corresponding `String` from a `romanNumeralDict` dictionary. This means the outer `for await in` loop iterates over `String` instances instead of the underlying `Int` values that `Counter` produces. Also, the dictionary doesn’t provide a key for `4`, and the closure throws an error for any key it can’t look up, so receiving this value from `Counter` ends the modified sequence with an error. ``` let romanNumeralDict: [Int: String] = [1: "I", 2: "II", 3: "III", 5: "V"] do { let stream = Counter(howHigh: 5) .map { (value) throws -> String in guard let roman = romanNumeralDict[value] else { throw MyError() } return roman } for try await numeral in stream { print(numeral, terminator: " ") } } catch { print("Error: \(error)") } // Prints "I II III Error: MyError() " ``` --- Copyright © 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)