Swift 3.0 の新機能に関して、新機能の追加と変更まわりを記した資料です。削除された機能や Objective-C 寄りの機能には触れていません。カジュアル Swift 勉強会での話を少しスリムにしつつ、調べきれなかった事柄を追加してあります。

1. /*
*/

2. /**
*/
/* @es_kumagai */

3. /**
*/

4.
#devsap

25. enum Bit : Int, Comparable, RandomAccessIndexType {
case Zero
case One
}

26.
struct UnsafePointer<Pointee> : Strideable, Hashable {
var pointee: Pointee { get }
subscript(i: Int) -> Pointee { get }
}

34.
class Item {
// 戻り値を使わないと警告される
@warn_unused_result
func makeFilter() -> Filter {…}
// 戻り値を使わなくても警告されない
func apply(filter: Filter) -> Item {…}
}

35.
class Item {
// 戻り値を使わないと警告される
func makeFilter() -> Filter {…}
// 戻り値を使わなくても警告されない
@discardableResult
func apply(filter: Filter) -> Item {…}
}

37. !
let optionalValue: Int! = 100

38. // 今は ImplicitlyUnwrappedOptional 型として認識
var a: Int!
// こちらは従来通り Optional 型として認識
var b: Int?

39. struct Value {
init!(source: Int) { … }
func doSomething() { … }
}
let value = Value(source: 10)
value?.doSomething() Value?
Value!

44. func add<T: FloatingPoint>(lhs: T, rhs: T) -> T {
return lhs + rhs
}

46. enum Item {
case binary(NSData)
}
let data1: NSMutableData = …
let data2: NSData = …
let item = Item.binary(data1)
data1.appendData(data2)

47. enum Item {
case binary(Data)
}
var data1: Data = …
let data2: Data = …
let item = Item.binary(data1)
data1.appendData(data2)

50. let pointer: UnsafePointer<Int> = …
if pointer != nil {
print(pointer.memory)
}
else {
}

51. let pointer: UnsafePointer<Int>? = …
if let value = pointer?.pointee {
print(value)
}
else {
}

53. // 最初のインデックス
var startIndex: Index { get }
// 最後の次のインデックス
var endIndex: Index { get }
// 指定したインデックスに該当する要素
subscript (position: Index) -> _Element { get }

54. // 最初のインデックス
var startIndex: Index { get }
// 最後の次のインデックス
var endIndex: Index { get }
// 指定したインデックスに該当する要素
subscript (position: Index) -> _Element { get }
// あるインデックスの次のインデックスを取得
func index(after i: Index) -> Index

56. // 前方移動性をもつ索引型
protocol ForwardIndexType: Equatable
// 前後方移動性をもつ索引型
protocol BidirectionalIndexType: ForwardIndexType
// どこへも自由に即時移動できる索引型
protocol RandomAccessIndexType: BidirectionalIndexType
// コレクションは集積性と、使用する索引を規定
protocol CollectionType {
associatedtype Index : ForwardIndexType

57. // 前方移動性をもつコレクション
protocol Collection: Indexable
// 前後方移動性をもつコレクション
protocol BidirectionalCollection: BidirectionalIndexable
// 範囲内を自由に即時移動できるコレクション
protocol RandomAccessCollection: RandomAccessIndexable
// インデックスに求められるのは比較性のみ
protocol Collection {
associatedtype Index : Comparable

58. // このコレクションは前後へ移動可能
struct MyCollection : BidirectionalCollection {
// 索引として文字列を使う
typealias Index = String
}

59. // Int を索引にもつデータ表現は実装の手間が増える
struct MyArray<Element> : RandomAccessCollection {
typealias Index = Int
}
// String を索引にもつデータ表現は簡略化される
struct Namelist : Collection {
typealias Index = String

63. protocol BooleanType {
var boolValue: Bool { get }
}

64. !, &&, ||
func && (lhs: Bool, rhs: () -> Bool) -> Bool
func || (lhs: Bool, rhs: () -> Bool) -> Bool
func ! (a: Bool) -> Bool

67. if /* comment */!isValid { ... }
value +/* comment */coefficient
!
+/*

68. optionalArray/* Comment */?.count
value+/* comment */coefficient
?
+

70. func f: (Type) -> Type = {
}
func test() -> (Type) -> Type {
}
func test(f: (Type) -> Type) {
}

71. let f: (Type) -> Bool = { value in
}

73. func something(first: Int, second: Int, third: Int) {
}
something(first: 1, second: 10, third: 3)

74. _
// ラベル名を label にする
func function(label value: Int) {
}
func function(_ label value: Int) {
}

76. :
@available(*, unavailable, renamed: "NewProtocol")
typealias PreviousProtocol = NewProtocol

78. // 定義では `` が必要
enum DrawingStyle {
case `default`
case `repeat`
case fit
}
// 使用時は `` が不要
let style = DrawingStyle.default

79. // 定義では `` が必要
class Object {
var `default`: Int
func `repeat`(_ times: Int) -> String { … }
}
// 使用時は `` が不要
let object = Object()
let value = object.default

80. // 定義では `` が必要
enum Evaluate {
case `self`
case `dynamicType`
}
// 使用時も `` が必要
let eval = Evaluate.`self`

82. // プロトコル型で使う
let p: A & B = Value()
// 型引数で使う
func doSomething<T: A & B>(_ value: T) {
}

86. struct Value : Equatable {
static func == (lhs: Value, rhs: Value) -> Bool {
}
}

88. // 既定値が指定された関数があったとき
func something(a:Int = 0, b:Int = 1, c:Int = 2) {
}
// 異なる順番で引数を渡せなくなった
something(b: 10, a: 20)

90. func function(@noescape f: () -> Int) {
}
func function(@autoclosure f: () -> Int) {
}

91. func function(f: @noescape () -> Int) {
}
func function(f: @autoclosure () -> Int) {
}

93. func function(f: () -> Int)
-> (@noescape (Int) -> Int) -> Int {
return { g in g(f()) }
}

95. func function() -> (@autoclosure () -> Int) -> Int {
return { (f: @autoclosure () -> Int) in f() }
}
// 関数で得た、関数を取る関数に、値をそのまま渡せる
let f = function()
let result = f(100)

97. func method(inout result: Int) {
}
func method(inOut result: Int) {
}

98. func method(result: inout Int) {
}
func method(inOut result: inout Int) {
}

99. func function() -> (result: inout Int) -> Void {
return { (result: inout Int) -> Void in
result = 700
}
}

100. let f: (inout Int) -> Void = {
return { $0 = 5000 }
}

102. func something(value: inout Int) {
let noescaped: @noescape () -> Void = {
value = 10
}
let escaped: () -> Void = { [value] in
print(value)
}
}

108. typealias NamedValues<T> = Dictionary<String, T>
typealias Vector<T> = (T, T)
typealias Filter<T,R> = (T) -> R

110. switch (value1, value2) {
case let (value?, nil), let (nil, value?):
return value
case let (value1?, value2?):
return value1 + value2
case (nil, nil):
return 0
}