Swiftは○○に似ている

# はじめに

Appleが[Swift](http://swift-lang.org/)という言語を発表した。
新しい言語をつくるのであれば既存の言語から良いアイディアは取り入れ悪いアイディアは取り入れないのが良い。

TwitterのTLを見ていると「Swiftは○○に似ている」という発言があったので、
どこら辺が似ているのかを自分の中で振り返ってみた。

（最初は「Swiftは○○のパクり」というタイトルにしたかったのだが、文全体を挑発的に書けなかったのでやめた）

間違っていることもあるはずなので、コメントは大歓迎である。

# Swift

全部紹介するのは無理なので、とりあえず [A Swift Tour](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GuidedTour.html#//apple_ref/doc/uid/TP40014097-CH2-XID_1) から引用したい。

## 基本文法

基本文法はC言語系だ。現在の手続き型言語はC++やJava等これが主流である。
（主流でない文法はFORTRAN、BASIC、Pascalなどなど。関数型だとまた全く違う）

## Simple Values

```swift
var myVariable = 42
myVariable = 50
let myConstant = 42
```

`let`や`var`のように、型からはじめるのではなく変数宣言から始める言語は結構多い。
<del>知る中ではVisualBasicが最古。</del> VB以前のBASICでも`DIM`という変数宣言をしていたそうだ。（コメントより）
こちらの文法のほうがパーサーが書きやすいという利点がある。

変数宣言で再代入できるか出来ないかを分けるのは私の知る限りではScalaが最初だった。
それより前の言語、例えばJavaでは、`final`修飾子をつけるなどして再代入を防いでいた。

```swift
let appleSummary = "I have \(apples) apples."
```

文字列中に式を埋め込むのはかなり古い言語からある。私の知る中ではBashが最古。
バックスラッシュ`\`で式展開をするのは初めて見た。

```swift
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
 
var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
```

配列と連想配列に専用の初期化構文を置くのはScript言語だとよくある。知る中ではPerlが最古。
多くの場合は、`Array`,`Dictionary`の専用の構文になっていることが多い。（TODO: Swiftでは専用構文なのか後で調べる）
（C++では汎用的な初期化構文がある。C#では配列とは別だがコレクション初期化構文がある）

## Control Flow

```swift
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
```

よくある。括弧`()`を使わないのは少し珍しいが、例えば Rust, Go などがある。

```swift
var optionalString: String? = "Hello"
optionalString == nil
 
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}
```

`null`(Swiftの場合は `nil`)を含むかもしれない値にoptional`?` マークを付けるのは珍しくない。知る中ではKotlinが最古だがアイディア自体はかなり昔から見た覚えがある、なんだっけか。
C#では値型でのみ`Nullable`が利用できる。（TODO: Swiftの`nil`たりえる変数全てに`?`がつくのかライブラリをのぞいてみる）

ifで 代入＋optionalの判別 をしているのを見たのはSwiftが初めて。正直KotlinやHackのようなコンテキストで判断するタイプのほうが（初見ではとっつきにくいが）スマートで良い。
代入を含むifでは`let`が一緒に出てくるので、よくある「比較と代入を間違える」ということが無いのは素晴らしい。

```swift
let vegetable = "red pepper"
switch vegetable {
case "celery":
    let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
    let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
    let vegetableComment = "Is it a spicy \(x)?"
default:
    let vegetableComment = "Everything tastes good in soup."
}
```

switch-caseに複雑なことを書ける言語は多い。スクリプト言語だとほとんどがそうで、関数型言語でもパターンマッチがある。C++, Java, C#のように「ジャンプ命令に変換」するタイプだとできない。
C系から比較すると`break`が不要なところに好感がもてる。

```swift
for (kind, numbers) in interestingNumbers {
  /* ... */
}
```

<del>for文でtupleにマッチさせるのは珍しい気がする。知る中ではScalaが最古。 
正確に言えば「for文」と「パターンマッチ」の両方を持つ言語が少ないのではないか。</del>

for文のループ変数に二値が使えるのは、Rubyなどいろいろある。
他にも「静的型付き関数型言語では変数を導入できる場所にパターンが書ける」とのこと。

<del>（TODO: Tuple以外でもマッチできるのか調べる。要はExtractor？の存在）</del>
extractorじゃなくて `=~`というのがあるそうだ。Rubyの`===`っぽい。

```swift
for i in 0..3 {
    firstForLoop += i
}
```

`..`による範囲式はPerlが最初かな？（TODO: 式なのかfor構文の一部なのか調べる）

> Use `..` to make a range that omits its upper value, and use `...` to make a range that includes both values.

とあるけどRubyと逆じゃないだろうか。そういうのはやめてほしい。

## Functions and Closures

```swift
func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")
```

型定義を後ろに書くパターン。関数型言語だと一般的。コロン`:`なのは、知る中でのOCamlが古いので最古はMLだろうか。Goでも型は後ろに書くが、コロンは書かないようだ。（後述）

```swift
func getGasPrices() -> (Double, Double, Double) {
    return (3.59, 3.69, 3.79)
}
```

Tupleの戻り値の型を宣言して、Tupleの値を返してる。関数型言語だと一般的。

```swift
func sumOf(numbers: Int...) -> Int {
    /* ... */
}
sumOf()
sumOf(42, 597, 12)
```

可変長引数を提供する言語は多い。
しかしC言語はマクロを用いて面倒なことをしていた。型付きの言語で言語構文に組み込んだのはJavaが最古だろうか？
可変長引数と部分適用は相性が悪いので関数型言語では見ないイメージ（わざわざ可変長にしなくてもリストでいいじゃんというね）

```swift
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)
```

高階関数を扱えるのは関数型言語だと当然だが、手続き型言語でも主流になってきた。
C言語でも関数ポインタは渡せるが、シグネチャが複雑になるのでよろしくない。
C++は関数内関数は書けてもクロージャを作らない。もしくは匿名関数の構文。

```swift
numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})
```

ラムダ式に`in`を使うのは初めて見た。
OCamlに let-in という構文があって `let x = 3 in x * x` という感じに使う。
使われる場所は違うけど、inの前で宣言、後ろでそれを利用した定義のところに同じ雰囲気を感じる。
型推論されるので、ラムダ式の型は省略できるようだ。

```swift
sort([1, 5, 3, 12, 2]) { $0 > $1 }
```

暗黙の引数名 `$0`はスクリプト言語だとよくある。記憶が定かではないが型付きの言語でもあったはず。
Scalaのプレースホルダーと違って`{`,`}`で囲まれていてラムダ式の範囲が明確。引数の順序を指定できるあたりがうれしい。

## Objects and Classes

```swift
class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
```

普通。Java, C#っぽい。メンバ変数でも型推論が効くのはうれしい。

```swift
var shape = Shape()
```

コンストラクタに`new`が要らない。知る限りではPythonが最古。Scalaだとコンパニオンオブジェクトを作ってnewをなくしてしまうことがある。

追記：

C++でもnew無しにコンストラクタを呼べる。というより`new`の有無によって振る舞いが異なり、newすると新しくヒープから確保し、そうでないと「その場所（関数内だとスタック）」に確保する。

```swift
init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 4
}
```

詳しく見ないといけないが、親クラスのコンストラクタを呼ぶ前に処理が入っている。C++, Java, C#でこういうのは出来ない。後述。
代入だけだからいけるのだろうか？（TODO: 調べる）

```swift
class EquilateralTriangle: NamedShape {
    /* ... */
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    override func simpleDescription() -> String {
        return "An equilateral triagle with sides of length \(sideLength)."
    }
}
```

プロパティはあって当然な機能な気がするけど、<del>知る中ではなぜかC#が最古。</del> Delphiにプロパティ構文があるそうだ。
Javaのgetter/setterはカッコ悪いよね。
`override`必須なのも（Javaはミスしたが）最近は一般的。

```swift
class TriangleAndSquare {
    var triangle: EquilateralTriangle {
    willSet {
        square.sideLength = newValue.sideLength
    }
    /* ... */
}
```

willSetというのは初めて見た。プロパティ代入へのフックのようだが専用構文は必要なのだろうか。

## Enumerations and Structures

```swift
enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
    /* ... */
}
```

知る中ではC#っぽいけどintから型付きのenumを作るのは他にもありそう。（D言語とかどうだっけ）
enumのswitch文が`.Ace`のようにドットで始まるのは初めて見た。なんでだろう。

```swift
struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
```

値型と参照型を`struct`と`class`で分けるところがC#っぽい。（D言語も同様）


```swift
enum ServerResponse {
    case Result(String, String)
    case Error(String)
}
```

variantとか判別共用体とか呼ばれる機能ですね。関数型だとよくある。
<del>「optional`?`」とこの機能が両方存在しているところは突っ込みたい。
（TODO: 実は一緒だったりしないか調べる）</del>
`Optional<T>`の糖衣構文のようだ。`Array<T>`も同様のよう。

## Protocols and Extensions

インタフェースです。
インスタンスメソッドだけではなく、クラスメソッドも制約をつけられるようだ。

```swift
struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
```

`mutating`というのは初めて見た。値型が自身を書き換える関数にマークする。
<del>おそらくstructをprotocolにキャストするときにboxingされてその結果コピーだけが書き換わって元の値が書き換わらないというC#でよくあるバグを防ぐのに使うのかなと思われる。</del> 用途はこれだけではないようだ。

コメントを参照してください。

## Generics

```swift
func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    var result = ItemType[]()
    for i in 0..times {
        result += item
    }
    return result
}
repeat("knock", 4)
```

C#の総称型と同様だと思われる。structがあるので型消去はされないと信じたい（TODO: 後で調べる）

```swift
func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}
anyCommonElements([1, 2, 3], [3])
```

総称型の制約の書き方はJavaとC#の間をとったようだ。（Javaのように`<>`の中に制約を書くが、C#のように関数名の後ろに宣言する。後述）

C#やJavaとは違い高階型（型引数を取る型、この名称であってる？）の制約もできるようだ。
構文は全然違うが、HaskellやScalaに存在する。

# さいごに

自分の知ってる言語と比較して振り返ってみたけど、良いところを取り込んだ普通によさそうな言語だった。
今後のAppleに期待したい。

# Appendix

## Goの関数宣言

Goはコロン無しで型を後ろに書く。
これで`x`,`y`の両方が`int`だと指定できるのがちょっと珍しい。

```go
func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}
```

## Javaのコンストラクタの例

例えばこんなコードがコンパイルできない。

```java
class Parent {
  private int pValue;
  Parent(int value) {
    pValue = value;
  }
}
class Child {
  private int cValue;
  Child(int value) {
    cValue = value; // 親のコンストラクタより先にフィールドを初期化
    super(0);
  }
}
```

## JavaとC#の総称型

Java

```java
public <T extends CharSequence, U extends List<Object>> int foo (T str, U list) {
	return 0;
}
```

C#

```csharp
public int Foo<T, U>(T str, U list)
		where T : IEnumerable<char>
		where U : List<Object> {
	return 0;
}
```