Swift2.x を Scala からみる

Swift2.xを
Scalaから見る
1
安達勇一
クラスメソッド株式会社
2015年11月11日
Ⓒ Classmethod, Inc.

2
安達勇一
• 2013/12 入社

• TwitterID: @UsrNameu1

• Github: https://github.com/
UsrNameu1

• Blog: http://dev.classmethod.jp/
author/yad

• ここ半年はサーバーサイドメイン

Topics for today
• ミックスイン
• 正格評価・遅延評価
• 変位指定
3Ⓒ Classmethod, Inc.

Topics for today
• 変位指定

ミックスイン
• 抽象インターフェイス
• デフォルト実装
• ミックスイン対象制限

ミックスイン
• ミックスイン(mix-in)とは？
クラスが「本来の型」に加えて、なんらかの任意の振
る舞いを提供していることを宣言するために、クラスが
実装する型
Bloch(2008) Eﬀective Java 2nd edition

ミックスイン

抽象インターフェイス(Scala)
• traitは抽象インターフェイスをサポートしている
trait AbstractTrait {
type DataType
val constant: DataType
var variable: DataType
def method(): DataType
}
Scala code

抽象インターフェイス(Scala)
• traitは抽象インターフェイスをサポートしている
type DataType
val constant: DataType
var variable: DataType
def method(): DataType
}
抽象型メンバー、定数、変数、メソッドが定義できる
Scala code

抽象インターフェイス(Swift)
• protocolは抽象インターフェイスをサポートしている
protocol AbstractProtocol {
typealias DataType
var constant: DataType { get }
var variable: DataType { get set }
func method() -> DataType
init(t: DataType)
subscript(i: Int) -> DataType { get }
func + (lhs: DataType, rhs: DataType)
-> DataType
}
Swift code

抽象インターフェイス(Swift)
• protocolは抽象インターフェイスをサポートしている
protocol AbstractProtocol {
typealias DataType
var constant: DataType { get }
var variable: DataType { get set }
func method() -> DataType
init(t: DataType)
subscript(i: Int) -> DataType { get }
func + (lhs: DataType, rhs: DataType)
-> DataType
} 抽象型メンバー、プロパティ、メソッド、イニシャライザ
サブスクリプト、演算子が定義できる
Swift code

ミックスイン

デフォルト実装(Scala)
• traitはデフォルト実装をサポートしている
type DataType = String
val constant: DataType = “aa”
var variable: DataType = “aaa”
def method(): DataType = { “aaaa” }
}
Scala code

デフォルト実装(Scala)
• traitはデフォルト実装をサポートしている
type DataType = String
val constant: DataType = “aa”
var variable: DataType = “aaa”
def method(): DataType = { “aaaa” }
}
デフォルトの実装をtraitの各メンバーに対して定義できる
Scala code

デフォルト実装(Swift 2.x)
• protocol extensionはデフォルト実装をサポートしている
extension AbstractProtocol {
typealias DataType = String
var constant: DataType { return “a” }
func method() -> DataType { return “aa” }
}
Swift code

デフォルト実装(Swift 2.x)
• protocol extensionはデフォルト実装をサポートしている
extension AbstractProtocol {
typealias DataType = String
var constant: DataType { return “a” }
func method() -> DataType { return “aa” }
}
デフォルトの実装をprotocolの各メンバーに対して定義できる
Swift code

ミックスイン

ミックスイン対象制限(Scala)
• traitは自分型アノテーションで継承の対象になる型を
限定できる
self: SomeClass =>
def method(): String = { “aaaa” }
}
Scala code

ミックスイン対象制限(Scala)
• traitは自分型アノテーションで継承の対象になる型を
限定できる
self: SomeClass =>
def method(): String = { “aaaa” }
}
Scala code
ミックスインの対象になる型をSomeClassに限定できる
→AbstractTraitはSomeClassと
そのサブ型からしか継承できない

ミックスイン対象制限(Swift 2.x)
• protocol extensionのSelfへの制約によって
デフォルト実装が使える継承の対象となる型を制限できる
extension AbstractProtocol
where Self: SomeClass {
func method() -> String { return “aa” }
}
Swift code

}
デフォルトの実装を使える型はSomeClassとそのサブ型のみ
Swift code

}
デフォルトの実装を使える型はSomeClassとそのサブ型のみ
Swift code
See also→
http://www.slideshare.net/UsrNameu1/swift2-protocol-extension

ミックスインのまとめ
Scala Swift
抽象インターフェイス
デフォルト実装
ミックスイン対象型への制約
trait protocol
trait protocol extension
traitでの
自分型アノテーション
protocol extensionでの
Self への制約

Topics for today
• 変位指定

正格評価・
遅延評価
• lazy修飾子
• 遅延引数
• 遅延コレクション

正格評価・遅延評価
• 評価(evaluation) とは？
式から値を計算し、取り出す操作

let a = 1 + 1
Swift code

let a = 1 + 1
1 + 1という式から2を計算し、取り出す
Swift code

let a = 1 + 1
1 + 1という式から2を計算し、取り出す
a という名前の定数に代入する
Swift code

• 正格評価(strict evaluation) とは？
評価結果が使用されるタイミングに関係なく
即時に行われる評価のこと
func add(a: Int, _ b: Int) -> Int {
return a + b
}
struct Component {
let c = add(1, 1)
}
Swift code

• 正格評価(strict evaluation) とは？
評価結果が使用されるタイミングに関係なく
即時に行われる評価のこと
return a + b
}
struct Component {
let c = add(1, 1)
}
cが用いられるタイミングに関係なく
インスタンス生成時に評価される
Swift code

• 遅延評価(strict evaluation) とは？
即時に行われず、後々必要になったタイミングで
行われる評価のこと
return a + b
}
struct LazyComponent {
lazy var d = add(1, 2)
}
Swift code

• 遅延評価(strict evaluation) とは？
即時に行われず、後々必要になったタイミングで
行われる評価のこと
return a + b
}
struct LazyComponent {
lazy var d = add(1, 2)
} dが用いられるタイミングで評価される
Swift code

正格評価・
遅延評価
• lazy修飾子
• 遅延引数

lazy修飾子（Scala）
• lazyをval(定数)の前につけると遅延評価になる

object LazyConstants {
lazy val const: String = {
println("computed")
"constant"
}
}
val a = LazyConstants.const
Scala code


println("computed")
"constant"
}
}
Scala code
宣言時には評価されない


println("computed")
"constant"
}
}
Scala code
宣言時には評価されない
アクセス時に評価され、
computed が出力される

lazy修飾子（Swift）
• lazyをvar(変数)の前につけると遅延評価になる

class LazyConstants {
lazy var const: String = {
print("computed")
return "constant"
}()
}
let constants = LazyConstants()
let const = constants.const
Swift code


print("computed")
return "constant"
}()
}
Swift code
インスタンス生成時には評価されない


print("computed")
return "constant"
}()
}
Swift code
インスタンス生成時には評価されない
プロパティアクセス時に評価され、

• グローバル変数、定数はlazy修飾子をつけなくても
自動的に遅延評価になる

let someConst: String = {
print("computed")
return "constant"
}()
let length = someConst.utf8.count
Swift code


print("computed")
return "constant"
}()
Swift code
この時点では評価されない


print("computed")
return "constant"
}()
Swift code
この時点では評価されない
アクセス時に評価され、

正格評価・
遅延評価
• lazy修飾子
• 遅延引数

遅延引数（Scala）
• 名前渡しパラメーターは引数の評価を遅延する

val assertionsEnabled = true
def byNameAssert(pred: => Boolean) =
if (assertionsEnabled && !pred)
throw new AssertionError
byNameAssert(2 > 5)
Scala code


byNameAssert(2 > 5)
Scala code
assertionsEnabled が真の時
初めて引数 pred を評価する


byNameAssert(2 > 5)
Scala code
assertionsEnabled が真の時
初めて引数 pred を評価する
評価は引数を渡すタイミングではなく、
byNameAssert内部の処理が走るタイミングで行われる

遅延引数（Swift）
• @autoclosureは引数の評価を遅延する

func myAnd(
lhs: Bool,
@autoclosure _ rhs: () -> Bool
) -> Bool {
if lhs { return rhs() }
else { return false }
}
let result = myAnd(true, 1 < 2)
Swift code


func myAnd(
lhs: Bool,
) -> Bool {
}
Swift code
lhs が真の時初めて引数 rhs を評価する


func myAnd(
lhs: Bool,
) -> Bool {
}
Swift code
lhs が真の時初めて引数 rhs を評価する
評価は引数を渡すタイミングではなく、
myAnd内部の処理が走るタイミングで行われる

正格評価・
遅延評価
• lazy修飾子
• 遅延引数

遅延コレクション（Scala）
• ビューはmap, ﬁlter等の変換メソッド処理を
遅延するコレクションを提供する

val vectorView = Vector(1 to 5: _*).view
val middleView =
vectorView.map { x => println(x); x * 2 }
middleView.map { _ + 3 }.force
Scala code


val middleView =
Scala code
遅延コレクション生成


val middleView =
Scala code
この時点では中の処理は実施されず
中間のVectorも作成されない


val middleView =
Scala codeforceメソッドで正格コレクションに戻され、
それまでの変換メソッド処理が実施される。
（1 2 3 4 5が出力される）
この時点では中の処理は実施されず
中間のVectorも作成されない

遅延コレクション（Swift 2.x）
• LazySequenceプロトコルはmap, ﬁlter等の変換
メソッド処理を遅延するコレクションを提供する

let lazyArr = [1,2,3,4,5].lazy
let middleArr = lazyArr.map { x -> Int in
print(x); return x * 2
}
let endArr = middleArr.map { x in x + 3 }
for _ in endArr { }
Swift code


}
for _ in endArr { }
Swift code


}
for _ in endArr { }
Swift code
この時点では中の処理は
実施されず、中間のArrayも作成されない


}
for _ in endArr { }
Swift code
必要になった時にそれまでの変換メソッド処理が実施される。
（1 2 3 4 5が出力される）
この時点では中の処理は
実施されず、中間のArrayも作成されない

遅延評価のまとめ
Scala Swift
lazy修飾子
遅延引数
遅延コレクション
つけると評価は遅延
つけると評価は遅延
グローバル定数変数は
つけなくても遅延
名前渡しパラメーター @autoclosure
コレクションに対して
.viewで生成
force で正格評価
コレクションに対して
.lazyで生成
必要なときに評価

Topics for today
• 変位指定

変位指定
• リスコフ置換原則
• 共変・反変
• 共変
• 反変

リスコフ置換原則
Let Φ(x) be a property provable about
objects x of type T. Then Φ(y) should be true
for objects y of type S where S is a subtype
of T.
Liskov, and Wing(1993) A Behavioral Notion of Subtyping

T型のオブジェクトxに関して属性 Φ(x)が真
→ T型の派生型であるS型のオブジェクトyに関して
属性Φ(y)が真であるべき

SがTの派生型なら
T型の値が使える箇所でS型の値も使える

SがTの派生型なら
T型の値が使える箇所でS型の値も使える
「派生型」として満たされるべき原則
（必ずしも「継承」を意味しない）

変位指定
• 共変・反変
• 共変
• 反変

共変・反変
• ある型が別の型の派生型かどうかを判別する
http://stackoverﬂow.com/questions/2723397/java-generics-what-is-pecs

共変・反変
型引数のない通常の型

共変・反変
T S
音楽は娯楽の「派生型」として置換可能

共変・反変
→継承関係のみを気にすればうまくいく
T S
音楽は娯楽の「派生型」として置換可能

型引数xのある型
共変・反変

共変・反変

メタルの作曲家は娯楽の提供者の
「派生型」として置換可能
T S
共変・反変

共変・反変

共変・反変
TS
有機物消費者は竹を食べるパンダの

共変・反変
→型引数の継承関係でうまく判断できないケースがある
TS
有機物消費者は竹を食べるパンダの

共変・反変
• 共変・反変で
型引数xのある型同士の派生型を判別する
共変(Covariant)型引数の場合

共変・反変
共変(Covariant)型引数の場合
→型引数の派生順序を引き継ぐ

型引数xの派生順序
「xの提供者」の派生順序

共変・反変
反変(Contravariant)型引数の場合

共変・反変
→型引数の派生順序が反転する

「xの消費者」の派生順序

共変・反変
→型引数の派生順序が反転する

「xの消費者」の派生順序
PECS
（Producer extends Consumer super）
と呼ばれる基準もある

共変・反変
• 共変・反変で型引数xのある型同士の派生型を判別する
型引数が複数あり、共変・反変が共存する場合
↓ ↑
T
S
U
V

共変・反変
↓ ↑
T
S
U
V
TはSの派生型 VはUの派生型

共変・反変
反変型引数共変型引数
↓ ↑
T
S
U
V

共変・反変
↓ ↑↑
T
S
U
V
[反変S, 共変V]は[反変T, 共変U]の派生型

共変・反変
→共変型引数については派生順序を保持、
反変型引数については派生順序を逆転
↓ ↑↑
T
S
U
V
[反変S, 共変V]は[反変T, 共変U]の派生型

共変・反変は派生型についての
判定材料を与える

変位指定
• 共変・反変
• 共変
• 反変

共変（Scala）
• ＋を型引数の前につけると共変となる
sealed abstract class List[+A] …
var anyList: List[Any] = Nil
val intList: List[Int] = List(2, 3, 4)
anyList = intList
Scala code

共変（Scala）
anyList = intList
Scala code
派生順序は Any > Int

共変（Scala）
anyList = intList
Scala code
型引数の派生順序が保存され、
List[Int] は List[Any]の派生型として扱える

共変（Objective-C）
• __covariantを型引数の前につけると共変となる
@interface NSArray<__covariant ObjectType>…
NSArray<NSObject *> *anyArray = @[];
NSArray<NSNumber *> *numberArray =
@[@2, @3, @4];
anyArray = numberArray;
Objective-C code

@[@2, @3, @4];
Objective-C code
派生順序は NSObject > NSNumber

@[@2, @3, @4];
Objective-C code
NSArray<NSNumber *>* は
NSArray<NSObject *>* の派生型として扱える

共変（Swift）
• Array<T>はTについて共変
struct Array<T> …
var anyArray: [Any] = []
let intArray: [Int] = [2, 3, 4]
anyArray = intArray
Swift code

共変（Swift）
struct Array<T> …
anyArray = intArray
Swift code

共変（Swift）
struct Array<T> …
anyArray = intArray
Swift code
Array<Int> は Array<Any> の派生型として扱える

共変（Swift）
struct Array<T> …
anyArray = intArray
Swift code
Array<Int> は Array<Any> の派生型として扱える
将来共変を表すためのキーワードが入るかも？（憶測

変位指定
• 共変・反変
• 共変
• 反変

反変（Scala）
• -を型引数の前につけると反変となる

class Consumer[-T] {
def consume(p: T) = {}
}
var anyConsumer: Consumer[Any] =
new Consumer[Any]()
var intConsumer: Consumer[Int] =
new Consumer[Int]()
intConsumer = anyConsumer
Scala code

反変（Scala）

}
new Consumer[Any]()
new Consumer[Int]()
Scala code

反変（Scala）

}
new Consumer[Any]()
new Consumer[Int]()
Scala code
型引数の派生順序が逆転、
Consumer[Any] は Consumer[Int]の派生型として扱える

反変（Objective-C）
• __contravariantを型引数の前につけると反変となる
@interface Consumer<__contravariant Type>
: NSObject
- (void)consume:(Type)obj;
@end
@implementation Consumer
- (void)consume:(id)obj {}
@end
Objective-C code

@interface Consumer<__contravariant Type>
: NSObject
- (void)consume:(Type)obj;
@end
@implementation Consumer
- (void)consume:(id)obj {}
@end
Objective-C code
実装の引数にはidを渡す


Consumer<NSObject *> *anyConsumer =
[Consumer<NSObject *> new];
Consumer<NSNumber *> *numberConsumer =
[Consumer<NSNumber *> new];
numberConsumer = anyConsumer;
Objective-C code


Objective-C code


Objective-C code
型引数の派生順序が逆転、
Consumer<NSObject *>* は
Consumer<NSNumber *>* の派生型として扱える

反変（Swift 2.1）
• T -> S (関数の型)はTについて反変、Sについて共変

func testVariance(foo:(Int) -> Any){ foo(1) }
func innerAnyInt(p1: Any) -> Int{ return 1 }
func innerAnyAny(p1: Any) -> Any{ return 1 }
func innerIntInt(p1: Int) -> Int{ return 1 }
func innerIntAny(p1: Int) -> Any{ return 1 }
Swift code
http://www.uraimo.com/2015/09/29/Swift2.1-Function-Types-Conversion-
Covariance-Contravariance/


Swift code
引数にIntかその上位派生型、
返り値にAnyかその下位派生型をもつ関数を許容


Swift code
引数にIntかその上位派生型、
返り値にAnyかその下位派生型をもつ関数を許容
これらの関数は引数がIntかその上位派生型Any
返り値がAnyかその下位派生型Int


testVariance(innerIntAny)
testVariance(innerAnyInt)
testVariance(innerAnyAny)
testVariance(innerIntInt)
Swift code


Swift code
渡される関数の型は全て (Int) -> Any の派生型


Swift code
将来反変を表すためのキーワードが入るかも？（憶測
渡される関数の型は全て (Int) -> Any の派生型

変位指定のまとめ
Scala ObjC Swift
共変
反変
[ +T ]
[ -T ]
<__covariant T>
<__contravariant T>
Array<T>
が対応
T -> S の引数型
Tが対応

• Effective Java 第二版項目18
http://www.amazon.co.jp/dp/4621066056
• Scala スケーラブルプログラミング §19.3
http://www.amazon.co.jp/dp/4844330845
• Java Generics: What is PECS?
http://stackoverflow.com/questions/2723397/java-generics-
what-is-pecs
References

Swift2.x を Scala からみる

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (17)

Similar to Swift2.x を Scala からみる

Similar to Swift2.x を Scala からみる (20)

More from Yuichi Adachi

More from Yuichi Adachi (10)

Swift2.x を Scala からみる