Swift EvolutionのAcceptedステータスまとめ (2017.1.27) - Protocol-oriented integers, Permit where clauses to constrain associated types, ...etc ref: http://qiita.com/hanawat/items/6e76d958a22b6e77d6ea

file0.swift

struct FooFooFooFooFoo {
    static func bar() { }
    func baz() {
        FooFooFooFooFoo.bar() // Before
        type(of: self).bar()  // Before
        Self.bar() // After
    }
}

file1.swift

func sortedArrays<T: Comparable>(arrays: [[T]]) -> [T] {

    // Error: `map` expects [T] -> [T], but
    // `Array.sorted` has type ([T]) -> () -> [T]
    return arrays.map(Array.sorted)
}

file10.swift

public func ==<Element : Equatable>(lhs: ContiguousArray<Element>, rhs: ContiguousArray<Element>) -> Bool

file2.swift

struct Foo {
    let x: Int
    func bar(y: Int) -> Int {
        return x + y
    }
}

let f = Foo.bar // (Foo) -> (Int) -> Int

let g = f(Foo(x: 2))(3) // Before
let g = f(Foo(x: 2), 3) // After

file3.swift

#if canImport(UIKit)
   // UIKit-based code
   #elseif canImport(Cocoa)
   // OSX code
   #elseif
   // Workaround/text, whatever
#endif

file4.swift

let foo: Int8 = 1
let bar = 2

// error: binary operator '<<' cannot be applied
// to operands of type 'Int8' and 'Int'
let baz = foo << bar

file5.txt

                +--------------+  +-------------+
        +------>+  Arithmetic  |  | Comparable  |
        |       |   (+,-,*,/)  |  | (==,<,>,...)|
        |       +-------------++  +---+---------+
        |                     ^       ^
+-------+------------+        |       |
|  SignedArithmetic  |      +-+-------+------+
|     (unary -)      |      |  BinaryInteger |
+------+-------------+      |  (words,%,...) |
       ^                    ++---+-----+-----+
       |         +-----------^   ^     ^-----------+
       |         |               |                 |
+------+---------++    +---------+-------------+  ++------------------+
|  SignedInteger  |    |  FixedWidthInteger    |  |  UnsignedInteger  |
|                 |    | (bitwise,overflow,...)|  |                   |
+---------------+-+    +-+-----------------+---+  ++------------------+
                ^        ^                 ^       ^
                |        |                 |       |
                |        |                 |       |
               ++--------+-+             +-+-------+-+
               |Int family |-+           |UInt family|-+
               +-----------+ |           +-----------+ |
                 +-----------+             +-----------+

file6.swift

protocol Foo {
    associatedtype Bar: Sequence where Bar.Iterator.Element == Int
    func baz() -> Bar
}

file7.swift

protocol Foo : Sequence where Iterator.Element == Int { ... }

file8.swift

// error: Use of undefined associated type 'Counter'
protocol Foo: Sequence where Counter: Bar {
    associatedtype Counter
}

protocol Foo: Sequence {
    associatedtype Counter: Bar
}

file9.swift

extension Array: Equatable where Element: Equatable {
  static func ==(lhs: Array<Element>, rhs: Array<Element>) -> Bool { ... }
}