// Check each pair of items to see if they are equivalent.

         for i in ..<someContainer.count {

             if someContainer[i] != anotherContainer[i] {

                 return false

             }

         }

 extension Promise where T: Collection { // From PromiseKit library

       // .......

 }

 /**

  If you need to pass a closure expression to a function as the function’s final argument

  and the closure expression is long, it can be useful to write it as a trailing closure

  instead. A trailing closure is written after the function call’s parentheses, even though

  it is still an argument to the function.

  */

 func someFunctionThatTakesClosure(a :Int, closure: () -> Void) {

     closure()

 }

 // Here's how you call this function without using a trailing closure:

 someFunctionThatTakesClosure(a: , closure: {

     // closure's body goes here

     print("closure as a parameter.")

 })

 // Here's how you call this function with a trailing closure instead:

 someFunctionThatTakesClosure(a: ) {

     // trailing closure's body goes here

     print("trailing closure.")

 }

 extension Int {

     func repetitions(task: (_ th: Int) -> Void) {

         for i in  ..< self { // "for _ in a..<b" ??

             task(i)

         }

     }

 }

 let iExtension: Int =

 iExtension.repetitions { (th:Int) in  // arguments for Closure

     print("\(th)th loop.")

 }

 print("+++++")

 iExtension.repetitions { th in  　　　　// arguments for Closure

     print("\(th)th loop.")

 }

 print("2. +++++++++")

 iExtension.repetitions( task: { th in  // arguments

     print("without trailing closure \(th)")

 })

 reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in

     return s1 > s2

 })

 // Inferring Type From Context

 reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )

 // Implicit Returns from Single-Expression Closures

 // Single-expression closures can implicitly return the result of their single

 // expression by omitting the return keyword from their declaration

 reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

 // Swift automatically provides shorthand argument names to inline closures,

 // which can be used to refer to the values of the closure’s

 // arguments by the names $0, $1, $2

 reversedNames = names.sorted(by: { $ > $ } )

　　statements

}

 func test_guard(_ i: Int) /* -> Void */ {

     guard i >  else {

         print("In test_guard() else clause.")

         return

     }

     print("In test_guard() the lastest statement.")

 }

 test_guard()

 // Output:

 In test_guard() else clause.

 func handleLocation(city: String?, state: String?,

                     latitude: CLLocationDegrees, longitude: CLLocationDegrees) {

 //......

 }

 let urlString = "http://api.openweathermap.org/data/2.5/weather?lat=" + "\(latitude)&lon=\(longitude)&appid=\(appID)"

 let url = URL(string: urlString)!

 let request = URLRequest(url: url)

     final func `catch`(on q: DispatchQueue, policy: CatchPolicy, else resolve: @escaping (Resolution<T>) -> Void, execute body: @escaping (Error) throws -> Void) {

         pipe { resolution in

             switch (resolution, policy) {

             case (.fulfilled, _):

                 resolve(resolution)

             case (.rejected(let error, _), .allErrorsExceptCancellation) where error.isCancelledError:

                 resolve(resolution)

             case (let .rejected(error, token), _):

                 contain_zalgo(q, rejecter: resolve) {

                     token.consumed = true

                     try body(error)

                 }

             }

         }

     }

 extension DispatchQueue {

 // ......

     public func async(group: DispatchGroup? = default, qos: DispatchQoS = default, flags: DispatchWorkItemFlags = default, execute work: @escaping @convention(block) () -> Swift.Void)

 // ......

 }

 func helloWithNames(names: String...) { // A: names's type is [String]

     for name in names {

         println("Hello, \(name)")

     }

 }

 // 2 names

 helloWithNames("Mr. Robot", "Mr. Potato")

 // Hello, Mr. Robot

 // Hello, Mr. Potato

 // 4 names

 helloWithNames("Batman", "Superman", "Wonder Woman", "Catwoman")

 // Hello, Batman

 // Hello, Superman

 // Hello, Wonder Woman

 // Hello, Catwoman