elementTransform => transformation

"element" just repeats type information and we haven't done anything
like that with any of the other closures.

Author: Dave Abrahams

stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb

@@ -60,10 +60,10 @@ public func withInvalidOrderings(invoke body: ((Int, Int) -> Bool) -> Void) {
 
 internal func _mapInPlace<C : MutableCollection>(
   _ elements: inout C,
-  _ elementTransform: @noescape (C.Iterator.Element) -> C.Iterator.Element
+  _ transformation: @noescape (C.Iterator.Element) -> C.Iterator.Element
 ) where C.Indices.Iterator.Element == C.Index {
   for i in elements.indices {
-    elements[i] = elementTransform(elements[i])
+    elements[i] = transformation(elements[i])
   }
 }
 

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -164,12 +164,12 @@ public struct FlatMapToOptionalTest {
   public init(
     _ expected: [Int32],
     _ sequence: [Int],
-    _ elementTransform: (Int) -> Int32?,
+    _ transformation: (Int) -> Int32?,
     file: String = #file, line: UInt = #line
   ) {
     self.expected = expected
     self.sequence = sequence
-    self.transform = elementTransform
+    self.transform = transformation
     self.loc = SourceLoc(file, line, comment: "test data")
   }
 }
@@ -230,12 +230,12 @@ public struct MapTest {
   public init(
     _ expected: [Int32],
     _ sequence: [Int],
-    _ elementTransform: (Int) -> Int32,
+    _ transformation: (Int) -> Int32,
     file: String = #file, line: UInt = #line
   ) {
     self.expected = expected
     self.sequence = sequence
-    self.transform = elementTransform
+    self.transform = transformation
     self.loc = SourceLoc(file, line, comment: "test data")
   }
 }

stdlib/private/StdlibCollectionUnittest/LoggingWrappers.swift.gyb

@@ -222,10 +222,10 @@ public struct ${Self}<
   }
 
   public func map<T>(
-    _ elementTransform: @noescape (Base.Iterator.Element) throws -> T
+    _ transformation: @noescape (Base.Iterator.Element) throws -> T
   ) rethrows -> [T] {
     Log.map[selfType] += 1
-    return try base.map(elementTransform)
+    return try base.map(transformation)
   }
 
   public func `where`(

stdlib/public/core/Collection.swift

@@ -1262,13 +1262,13 @@ extension Collection {
   ///     let letterCounts = cast.map { $0.characters.count }
   ///     // 'letterCounts' == [6, 6, 3, 4]
   ///
-  /// - Parameter elementTransform: A mapping closure. `transform` accepts an
+  /// - Parameter transformation: A mapping closure. `transformation` accepts an
   ///   element of this sequence as its parameter and returns a transformed
   ///   value of the same or of a different type.
   /// - Returns: An array containing the transformed elements of this
   ///   sequence.
   public func map<T>(
-    _ elementTransform: @noescape (Iterator.Element) throws -> T
+    _ transformation: @noescape (Iterator.Element) throws -> T
   ) rethrows -> [T] {
     let count: Int = numericCast(self.count)
     if count == 0 {
@@ -1281,7 +1281,7 @@ extension Collection {
     var i = self.startIndex
 
     for _ in 0..<count {
-      result.append(try elementTransform(self[i]))
+      result.append(try transformation(self[i]))
       formIndex(after: &i)
     }
 

stdlib/public/core/ExistentialCollection.swift.gyb

@@ -145,7 +145,7 @@ internal class _AnyRandomAccessCollectionBox<Element>
   internal var _underestimatedCount: Int { _abstract() }
 
   internal func _map<T>(
-    _ elementTransform: @noescape (Element) throws -> T
+    _ transformation: @noescape (Element) throws -> T
   ) rethrows -> [T] {
     _abstract()
   }
@@ -334,9 +334,9 @@ internal final class _${Kind}Box<S : ${Kind}> : _Any${Kind}Box<S.Iterator.Elemen
     return _base.underestimatedCount
   }
   internal override func _map<T>(
-    _ elementTransform: @noescape (Element) throws -> T
+    _ transformation: @noescape (Element) throws -> T
   ) rethrows -> [T] {
-    return try _base.map(elementTransform)
+    return try _base.map(transformation)
   }
   internal override func _where(
     _ isIncluded: @noescape (Element) throws -> Bool
@@ -577,9 +577,9 @@ extension Any${Kind} {
   }
 
   public func map<T>(
-    _ elementTransform: @noescape (Element) throws -> T
+    _ transformation: @noescape (Element) throws -> T
   ) rethrows -> [T] {
-    return try _box._map(elementTransform)
+    return try _box._map(transformation)
   }
 
   public func `where`(

stdlib/public/core/FlatMap.swift

@@ -11,70 +11,70 @@
 //===----------------------------------------------------------------------===//
 
 extension LazySequenceProtocol {
-  /// Returns the concatenated results of mapping `elementTransform`
+  /// Returns the concatenated results of mapping `transformation`
   /// over `self`.  Equivalent to
   ///
-  ///     self.map(elementTransform).flatten()
+  ///     self.map(transformation).flatten()
   ///
   /// - Complexity: O(1)
   public func flatMap<SegmentOfResult : Sequence>(
-    _ elementTransform: (Elements.Iterator.Element) -> SegmentOfResult
+    _ transformation: (Elements.Iterator.Element) -> SegmentOfResult
   ) -> LazySequence<
     FlattenSequence<LazyMapSequence<Elements, SegmentOfResult>>> {
-    return self.map(elementTransform).flatten()
+    return self.map(transformation).flatten()
   }
 
   /// Returns a `LazyMapSequence` containing the concatenated non-nil
-  /// results of mapping `elementTransform` over this `Sequence`.
+  /// results of mapping `transformation` over this `Sequence`.
   ///
   /// Use this method to receive only nonoptional values when your
   /// transformation produces an optional value.
   ///
-  /// - Parameter elementTransform: A closure that accepts an element of this
+  /// - Parameter transformation: A closure that accepts an element of this
   /// sequence as its argument and returns an optional value.
   public func flatMap<ElementOfResult>(
-    _ elementTransform: (Elements.Iterator.Element) -> ElementOfResult?
+    _ transformation: (Elements.Iterator.Element) -> ElementOfResult?
   ) -> LazyMapSequence<
     LazyFilterSequence<
       LazyMapSequence<Elements, ElementOfResult?>>,
     ElementOfResult
   > {
-    return self.map(elementTransform).where { $0 != nil }.map { $0! }
+    return self.map(transformation).where { $0 != nil }.map { $0! }
   }
 }
 
 extension LazyCollectionProtocol {
-  /// Returns the concatenated results of mapping `elementTransform` over
+  /// Returns the concatenated results of mapping `transformation` over
   /// `self`.  Equivalent to 
   ///
-  ///     self.map(elementTransform).flatten()
+  ///     self.map(transformation).flatten()
   ///
   /// - Complexity: O(1)
   public func flatMap<SegmentOfResult : Collection>(
-    _ elementTransform: (Elements.Iterator.Element) -> SegmentOfResult
+    _ transformation: (Elements.Iterator.Element) -> SegmentOfResult
   ) -> LazyCollection<
     FlattenCollection<
       LazyMapCollection<Elements, SegmentOfResult>>
   > {
-    return self.map(elementTransform).flatten()
+    return self.map(transformation).flatten()
   }
 
   /// Returns a `LazyMapCollection` containing the concatenated non-nil
-  /// results of mapping elementTransform over this collection.
+  /// results of mapping transformation over this collection.
   ///
   /// Use this method to receive only nonoptional values when your
   /// transformation produces an optional value.
   ///
-  /// - Parameter elementTransform: A closure that accepts an element of this
+  /// - Parameter transformation: A closure that accepts an element of this
   /// collection as its argument and returns an optional value.
   public func flatMap<ElementOfResult>(
-    _ elementTransform: (Elements.Iterator.Element) -> ElementOfResult?
+    _ transformation: (Elements.Iterator.Element) -> ElementOfResult?
   ) -> LazyMapCollection<
     LazyFilterCollection<
       LazyMapCollection<Elements, ElementOfResult?>>,
     ElementOfResult
   > {
-    return self.map(elementTransform).where { $0 != nil }.map { $0! }
+    return self.map(transformation).where { $0 != nil }.map { $0! }
   }
 }
 
@@ -83,36 +83,36 @@ extension LazyCollectionProtocol
   Self : BidirectionalCollection,
   Elements : BidirectionalCollection
 {
-  /// Returns the concatenated results of mapping `elementTransform` over
+  /// Returns the concatenated results of mapping `transformation` over
   /// `self`.  Equivalent to 
   ///
-  ///     self.map(elementTransform).flatten()
+  ///     self.map(transformation).flatten()
   ///
   /// - Complexity: O(1)
   public func flatMap<SegmentOfResult : Collection>(
-    _ elementTransform: (Elements.Iterator.Element) -> SegmentOfResult
+    _ transformation: (Elements.Iterator.Element) -> SegmentOfResult
   ) -> LazyCollection<
     FlattenBidirectionalCollection<
       LazyMapBidirectionalCollection<Elements, SegmentOfResult>>>
     where SegmentOfResult : BidirectionalCollection {
-    return self.map(elementTransform).flatten()
+    return self.map(transformation).flatten()
   }
 
   /// Returns a `LazyMapBidirectionalCollection` containing the concatenated non-nil
-  /// results of mapping elementTransform over this collection.
+  /// results of mapping transformation over this collection.
   ///
   /// Use this method to receive only nonoptional values when your
   /// transformation produces an optional value.
   ///
-  /// - Parameter elementTransform: A closure that accepts an element of this
+  /// - Parameter transformation: A closure that accepts an element of this
   /// collection as its argument and returns an optional value.
   public func flatMap<ElementOfResult>(
-    _ elementTransform: (Elements.Iterator.Element) -> ElementOfResult?
+    _ transformation: (Elements.Iterator.Element) -> ElementOfResult?
   ) -> LazyMapBidirectionalCollection<
     LazyFilterBidirectionalCollection<
       LazyMapBidirectionalCollection<Elements, ElementOfResult?>>,
     ElementOfResult
   > {
-    return self.map(elementTransform).where { $0 != nil }.map { $0! }
+    return self.map(transformation).where { $0 != nil }.map { $0! }
   }
 }

stdlib/public/core/Map.swift.gyb

@@ -204,11 +204,11 @@ public struct ${Self}<
 extension LazySequenceProtocol {
   /// Returns a `LazyMapSequence` over this `Sequence`.  The elements of
   /// the result are computed lazily, each time they are read, by
-  /// calling `elementTransform` function on a base element.
+  /// calling `transformation` function on a base element.
   public func map<U>(
-    _ elementTransform: (Elements.Iterator.Element) -> U
+    _ transformation: (Elements.Iterator.Element) -> U
   ) -> LazyMapSequence<Self.Elements, U> {
-    return LazyMapSequence(_base: self.elements, transform: elementTransform)
+    return LazyMapSequence(_base: self.elements, transform: transformation)
   }
 }
 
@@ -221,13 +221,13 @@ extension LazyCollectionProtocol
 {
   /// Returns a `LazyMapCollection` over this `Collection`.  The elements of
   /// the result are computed lazily, each time they are read, by
-  /// calling `elementTransform` function on a base element.
+  /// calling `transformation` function on a base element.
   public func map<U>(
-    _ elementTransform: (Elements.Iterator.Element) -> U
+    _ transformation: (Elements.Iterator.Element) -> U
   ) -> LazyMap${collectionForTraversal(Traversal)}<Self.Elements, U> {
     return LazyMap${collectionForTraversal(Traversal)}(
       _base: self.elements,
-      transform: elementTransform)
+      transform: transformation)
   }
 }
 

stdlib/public/core/Optional.swift

@@ -157,11 +157,11 @@ public enum Optional<Wrapped> : NilLiteralConvertible {
   /// - Returns: The result of the given closure. If this instance is `nil`,
   ///   returns `nil`.
   public func map<U>(
-    _ elementTransform: @noescape (Wrapped) throws -> U
+    _ transformation: @noescape (Wrapped) throws -> U
   ) rethrows -> U? {
     switch self {
     case .some(let y):
-      return .some(try elementTransform(y))
+      return .some(try transformation(y))
     case .none:
       return .none
     }
@@ -185,10 +185,10 @@ public enum Optional<Wrapped> : NilLiteralConvertible {
   /// - Parameter f: A closure that takes the unwrapped value of the instance.
   /// - Returns: The result of the given closure. If this instance is `nil`,
   ///   returns `nil`.
-  public func flatMap<U>(_ elementTransform: @noescape (Wrapped) throws -> U?) rethrows -> U? {
+  public func flatMap<U>(_ transformation: @noescape (Wrapped) throws -> U?) rethrows -> U? {
     switch self {
     case .some(let y):
-      return try elementTransform(y)
+      return try transformation(y)
     case .none:
       return .none
     }

stdlib/public/core/Sequence.swift

@@ -368,13 +368,13 @@ public protocol Sequence {
   ///     let letterCounts = cast.map { $0.characters.count }
   ///     // 'letterCounts' == [6, 6, 3, 4]
   ///
-  /// - Parameter transform: A mapping closure. `transform` accepts an
+  /// - Parameter transform: A mapping closure. `transformation` accepts an
   ///   element of this sequence as its parameter and returns a transformed
   ///   value of the same or of a different type.
   /// - Returns: An array containing the transformed elements of this
   ///   sequence.
   func map<T>(
-    _ elementTransform: @noescape (Iterator.Element) throws -> T
+    _ transformation: @noescape (Iterator.Element) throws -> T
   ) rethrows -> [T]
 
   /// Returns an array containing, in order, the elements of the sequence
@@ -709,13 +709,13 @@ extension Sequence {
   ///     let letterCounts = cast.map { $0.characters.count }
   ///     // 'letterCounts' == [6, 6, 3, 4]
   ///
-  /// - Parameter elementTransform: A mapping closure. `elementTransform` accepts an
+  /// - Parameter transformation: A mapping closure. `transformation` accepts an
   ///   element of this sequence as its parameter and returns a transformed
   ///   value of the same or of a different type.
   /// - Returns: An array containing the transformed elements of this
   ///   sequence.
   public func map<T>(
-    _ elementTransform: @noescape (Iterator.Element) throws -> T
+    _ transformation: @noescape (Iterator.Element) throws -> T
   ) rethrows -> [T] {
     let initialCapacity = underestimatedCount
     var result = ContiguousArray<T>()
@@ -725,11 +725,11 @@ extension Sequence {
 
     // Add elements up to the initial capacity without checking for regrowth.
     for _ in 0..<initialCapacity {
-      result.append(try elementTransform(iterator.next()!))
+      result.append(try transformation(iterator.next()!))
     }
     // Add remaining elements, if any.
     while let element = iterator.next() {
-      result.append(try elementTransform(element))
+      result.append(try transformation(element))
     }
     return Array(result)
   }