@interface SomeObject : NSObject
@property NSMutableArray *array;	// defaults to strong & atomic
@end

for (NSInteger i = 0; i < 200; i++) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
        _array = [NSMutableArray array];
    });
}

_array = [NSMutableArray array];

NSMutableArray *temp = [NSMutableArray array];
[temp retain];
[_array release];
_array = temp;

for (NSInteger i = 0; i < 200; i++) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
        self.array = [NSMutableArray array];
        [self.array addObject:@"a"];
        [self.array addObject:@"b"];
        [self.array addObject:@"c"];
    });
}

for (NSInteger i = 0; i < 200; i++) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
        NSMutableArray *array = [NSMutableArray array];
        [array addObject:@"a"];
        [array addObject:@"b"];
        [array addObject:@"c"];
        self.array = array;
    });
}

let π = 3.14159

/* this is the start of the first multiline comment
/* this is the second, nested multiline comment */
this is the end of the first multiline comment */

let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let decimalInteger = 17
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

typealias AudioSample = UInt16

let response = (statusCode: 200, description: "OK")
let (statusCode, _) = response
let statusCode = response.statusCode
let statusCode = response.0

var string: String 	// 未初始化, 不可为nil.
var string: String?	// 已初始化, 可为nil, 方法调用时需unwrap.
var string: String!	// 已初始化, 可为nil, 方法调用时无需unwrap, 但若值为nil, 触发runtime error.

// a) 强制解析
if convertedNumber != nil {
    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} 

// b) 可选绑定
if let actualNumber = possibleNumber.toInt() {
    println("\(possibleNumber) has an integer value of \(actualNumber)")
}

// c) 隐式解析
let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString)

// 可选绑定陷阱, 可选绑定只判定optional.
let bool: Bool? = false
if let value = bool {	// value = false
    println("whatever")	// 正确的写法需要在这里判别value
}

var `class` = 5
(`class`) = 6
println(`class`)

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message is "3 times 2.5 is 7.5"

var word = "cafe"
println("the number of characters in \(word) is \(countElements(word))")
// prints "the number of characters in cafe is 4"
 
word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
println("the number of characters in \(word) is \(countElements(word))")
// prints "the number of characters in café is 4"

string.unicodeScalars 	// UnicodeScalarView类型, 21位数字, Swift原生String选用.
string.utf8			 	// UTF8View类型, UInt8集合.
string.utf16			// UTF16View类型, UInt16集合.

array.append("A")
array += ["A"]				// 即使只有一个元素也需要方括号
array += ["A", "B", "C"]

array[0] = "A"
array[1...5] = ["B", "C"]	// 个数无需相等

for item in shoppingList {
    println(item)
}
for (index, value) in enumerate(shoppingList) {
    println("Item \(index + 1): \(value)")
}

var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
let element = array3D[1][0] // [5, 6]

if let oldValue = dict.updateValue("VALUE", forKey: "KEY") {
    println("The old value for KEY was \(oldValue).")
}

for (key, value) in dict {
    println("\(key): \(value)")
}

let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " a prime number, and also"
    fallthrough
default:
    description += " an integer."
}

switch count {
case 0:
    naturalCount = "no"
case 1, 2, 3, 4
    naturalCount = "few"
case 5...10:
    naturalCount = "some"
default:
    naturalCount = "lots of"
}

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    println("(0, 0) is at the origin")
case (let x, 0):
    println("(\(somePoint.0), 0) is on the x-axis")
case (0, let y):
    println("(0, \(y) is on the y-axis")
case (-2...2, -2...2):
    println("(\(somePoint.0), \(somePoint.1)) is inside the box")
default:
    println("(\(somePoint.0), \(somePoint.1)) is outside of the box")
}

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    println("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    println("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    println("(\(x), \(y)) is just some arbitrary point")
}

let contains = (1...5 ~= 3)         // true
let contains = ("a"..."z" ~= "c")   // true

gameLoop: while square != finalSquare {
    if ++diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // 到达最后一个方块，游戏结束
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // 超出最后一个方块，再掷一次骰子
        continue gameLoop
    default:
        // 本次移动有效
        square += diceRoll
        square += board[square]
    }
}

func <Function Name>(<Parameters List>) -> <Return Type> {
	// function body
	return <Return Value>
}

func function(p1: Int, _ p2: Int, #p3: Int, param4 p4: Int) {
    // whatever
}
function(1, 2, p3: 3, param4: 4)

func join(s1: String, s2: String, joiner: String = " ") -> String {
    return s1 + joiner + s2
}
join("hello", "world", joiner: "-") // 默认值参数项会自动添加外部参数名(同#), 可以使用下划线(_)移除外部参数名

func arithmeticMean(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}

func swapTwoInts(inout a: Int, inout b: Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}
swapTwoInts(&someInt, &anotherInt)	// 调用时需加&, 格式与传引用相似

// function
func add(to: Int, value: Int) -> Int {
    return value + to
}
// nested function
func addNested(to: Int) -> (Int -> Int) {
    func advanceBy(value: Int) -> Int {
        return value + to;
    }
    return advanceBy
}
// curried function
func addCurried(to: Int)(value: Int) -> Int {
    return value + to
}

let result = add(1, 2)                      // 1 + 2 = 3
let nestedFunc = addNested(1)               // 1 + ? = ?
let nestedResult = nestedFunc(2)            // 1 + 2 = 3
let curriedFunc = addCurried(1)             // 1 + ? = ?
let curriedResult = curriedFunc(value: 2)   // 1 + 2 = 3

func simpleAssert(condition: @autoclosure () -> Bool, message: String) {
    if !condition() {
        println(message)
    }
}
simpleAssert(5 % 2 == 0, "5 isn't an even number.")

let backwards: (String, String) -> Bool = {
    (s1: String, s2: String) -> Bool in
    return s1 > s2
}
let reversed = sorted(names, backwards)

// 类型推断
let backwards: (String, String) -> Bool = {
    s1, s2 in
    return s1 > s2
}

// 隐式返回
let backwards: (String, String) -> Bool = {
    (s1: String, s2: String) -> Bool in
    s1 > s2
}

// 参数缩写
let backwards: (String, String) -> Bool = {
    return $0 > $1
}

// 类型推断+隐式返回+参数缩写
let backwards: (String, String) -> Bool = {
    $0 > $1
}

let reversed = sorted(names, >)

func someFunctionThatTakesAClosure(closure: () -> ()) {
    // function body goes here
}
// 普通闭包
someFunctionThatTakesAClosure({
    // closure's body goes here
})
// 尾随闭包
someFunctionThatTakesAClosure() {
    // trailing closure's body goes here
}
// 闭包作为函数唯一参数时括号都可以省略
someFunctionThatTakesAClosure {
    // trailing closure's body goes here
}

enum CompassPoint {
    case North	// 不等于0
    case South
    case East
    case West
}

enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

let directionToHead: Planet = .Venus

enum Barcode {
    case UPCA(Int, Int, Int, Int)
    case QRCode(String)
}
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)

switch productBarcode {
case .UPCA(let numberSystem, let manufacturer, let product, let check):
    println("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
case .QRCode(let productCode):
    println("QR code: \(productCode).")
}

enum ASCIIControlCharacter: Character {
    case Tab = "\t"
    case LineFeed = "\n"
    case CarriageReturn = "\r"
}

let possiblePlanet = Planet(rawValue: 7)
// possiblePlanet is of type Planet? and equals Planet.Uranus

view.frame.size.width = 100

// 且算变通
class SomeClass {
    struct storedTypeProperty {
        static var value: Int = 0
    }
    class var computedTypeProperty: Int {
        get {
            return self.storedTypeProperty.value
        }
        set {
            self.storedTypeProperty.value = newValue
        }
    }
}

class Superclass {
    var value: Int! {
        didSet {
            self.value 		// console: 3
        }
    }
    init(value: Int) {
        self.value = value
    }
}
class Subclass: Superclass {
    var subvalue: Int! {
        didSet {
            self.subvalue	// not triggered at all
        }
    }
    override init(value: Int) {
        self.subvalue = 2
        super.init(value: value)
        self.value = 3     // trigger
        self.subvalue = 4
    }
}
var sub = Subclass(value: 1)

// 这是个反例...
class Superclass {
    var storedInt: Int = 0
    var calculatedInt: Int {
        get {
            return self.storedInt
        }
        set {
            self.storedInt = newValue		// called twice with 1, 0
        }
    }
}

class Subclass: Superclass {
    override var calculatedInt: Int {
        didSet {
            self.calculatedInt
            
            if self.calculatedInt > 0 {
                self.calculatedInt -= 1;	// called twice with 1, 0
            }
        }
    }
}

var instance = Subclass()
instance.calculatedInt = 1

struct Point {
  var x = 0.0, y = 0.0
  mutating func moveByX(deltaX: Double, y deltaY: Double) {
    self = Point(x: x + deltaX, y: y + deltaY)
  }
}

subscript(index: Int) -> Int {
    get {
        // return an appropriate subscript value here
    }
    set {
        // perform a suitable setting action here
    }
}

// a) designated initializer, 每个类至少有一个, 需初始化所有class引入的存储属性, 并调用父类的构造器以完成链式构造. 
init(...) {
    // first phase - initialize ALL stored property
    self.storedProperty = ...   // if default value is not provided
    super.init(...)             // delegate up

    // second phase - customize stored property
    self.storedProperty = ...
    super.storedProperty = ...
}

// b) convenience initializer, 数量不限, 处理输入并调用class的designated initializer以委托构造.
convenience init(parameters) {
    // first phase - initialize ALL stored property
    self.init(...)              // delegate across, should be a designated initializer

    // second phase - customize stored property
    self.storedProperty = ...
    super.storedProperty = ...
}

class Animal {
    required init () {

    }
}
class Mammal: Animal {

}
class Human: Mammal {   // 不必实现init, 危险的required丢失特性
    var name: String
    init(name: String) {
        self.name = name;
        super.init()
    }
}
var human = Human(name: "")

class SomeClass {
    let someProperty: SomeType = {
        // create a default value for someProperty inside this closure
        // someValue must be of the same type as SomeType
        return someValue
    }()
}

class Country {
    let name: String
    let capitalCity: City!          // 隐式解析, 默认值nil
    init(name: String, capitalName: String) {
        self.name = name            // first phase完成
        self.capitalCity = City(name: capitalName, country: self)   // 可以在capitalCity没有actual值的情况下使用self
    }
}
class City {
    let name: String
    unowned let country: Country    // 解除循环引用
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

lazy var someClosure: () -> String = {
    [unowned self, weak someInstance = self.somewhat] in
    // closure body goes here
}

class Person {
    var residence: Residence?
}
class Residence {
    var numberOfRooms = 1

    func printNumberOfRooms() {
        println("The number of rooms is \(numberOfRooms)")
    }
}

// 由于存在可选链, 即使numberOfRooms的推断类型为Int, number的类型也会是Int?. 
// 可选性质不受链内可选节点数影响. 
// 链内任意节点为nil都会导致整条链失败. 
let number = consumers.first?.residence?.numberOfRooms

// 当方法有返回值时, 处理方式与访问属性相同. 
// 当方法返回类型为Void时, 其本质是空元组(), 则可选链的返回类型为()?.
// 可以通过返回值判定调用是否成功.
let succ: ()? = consumers.first?.residence?.printNumberOfRooms()
if succ != nil {
	println("It was possible to print the number of rooms.")
}

// 赋值语句类似于方法调用
if (consumers.first?.residence?.numberOfRooms = 3) == nil {
    println("Failed in setting the number of rooms.")
}

var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91		// set
testScores["Bev"]?[0]++			// get

if item is Movie {
    ++movieCount
} 

// as! example
for movie in library as! [Movie] {
    println("Movie: '\(movie.name)', dir. \(movie.director)")
}

// as? example
for object in someObjects {
    if let movie = object as? Movie {
        println("Movie: '\(movie.name)', dir. \(movie.director)")
    }
}

// 在switch中使用as, 而非as?, 以检查类型. 
for thing in things {
    switch thing {
    // 0值判别
    case 0 as Int:
        println("zero as an Int")
    case 0 as Double:
        println("zero as a Double")

    // Int 判别
    case let someInt as Int:
        println("an integer value of \(someInt)")
    // Double 正数判别
    case let someDouble as Double where someDouble > 0:
        println("a positive double value of \(someDouble)")
    // Double 负数判别
    case is Double:
        println("some other double value that I don't want to print")

    // String 判别
    case let someString as String:
        println("a string value of \"\(someString)\"")
    // 元组值绑定
    case let (x, y) as (Double, Double):
        println("an (x, y) point at \(x), \(y)")
    // func 判别
    case let stringConverter as String -> String:
        println(stringConverter("Michael"))
    default:
        println("something else")
    }
}

struct Card {
    enum Suit: Character {
       case Spades = "♠", Hearts = "♡", Diamonds = "♢", Clubs = "♣"
    }
    enum Rank: Int {
       case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten
       case Jack, Queen, King, Ace
    }
}

enum Rank: Int {
   case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten
   case Jack, Queen, King, Ace
}

let r1 = Rank.Two
let r2 = Card.Rank.Two
let r3 = Card.Rank.Two

if r1 == r2 {           // compile error
    println("equals")
}
if r2 == r3 {           
    println("equals")   // prints equal
}

protocol AnotherProtocol {
    class var someTypeProperty: Int { get set }
}

protocol AgeRequired {
    init(age: UInt)
}
class Animal: AgeRequired {
    required init (age: UInt) { // required必不可少
        // whatever
    }
}
class Mammal: Animal {
}
class Human: Mammal {
    var name: String
    init(name: String) {
        self.name = name;
        super.init(age: 0)
    }
}
var human = Human(name: "") // init(age:)特性丢失, init默认不继承特性也是挺危险的.

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
    // class-only protocol definition goes here
}

@objc protocol CounterDataSource {
    optional func incrementForCount(count: Int) -> Int
    optional var fixedIncrement: Int { get }
}

func swapTwoValues<T>(inout a: T, inout b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3, anotherInt = 107
swapTwoValues(&someInt, &anotherInt)

struct Stack<T> {
    var items = [T]()
    mutating func push(item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
}

extension Stack {
    var topItem: T? {
        return items.isEmpty ? nil : items[items.count - 1]
    }
}

func allItemsMatch <
    C1: Container, 
    C2: Container where C1.ItemType == C2.ItemType, 
    C1.ItemType: Equatable
> (someContainer: C1, anotherContainer: C2) -> Bool {
    // check that both containers contain the same number of items
    if someContainer.count != anotherContainer.count {
        return false
    }  
    // check each pair of items to see if they are equivalent
    for i in 0..<someContainer.count {
        if someContainer[i] != anotherContainer[i] {
            return false
        }
    }
    // all items match, so return true
    return true
}

protocol Container {
    typealias ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

struct Stack<T>: Container {
    // original Stack<T> implementation
    var items = [T]()
    mutating func push(item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
    // conformance to the Container protocol
    typealias ItemType = T
    mutating func append(item: T) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> T {
        return items[i]
    }
}

var pi: Int8 = 2    // 0000 0010
var ni: Int8 = -2   // 1111 1110
var ui: UInt8 = 2   // 0000 0010

pi << 5 // 0100 0000 = 64
ni << 5 // 1100 0000 = -64
ui << 5 // 0100 0000 = 64

pi << 6 // 1000 0000 = -128 [overflow]
ni << 6 // 1000 0000 = -128
ui << 6 // 1000 0000 = 128

pi << 7 // 0000 0000 = 0
ni << 7 // 0000 0000 = 0
ui << 7 // 0000 0000 = 0

pi >> 1 // 0000 0001 = 1
ni >> 1 // 1111 1111 = -1
ui >> 1 // 0000 0001 = 1

pi >> 2 // 0000 0000 = 0
ni >> 2 // 1111 1111 = -1
ui >> 2 // 0000 0000 = 0

var overflow = UInt8.max &+ 1   // 0, 上溢, 从最大到最小
var underflow = Int8.min &- 1   // 127, 下溢, 从最小到最大

infix operator +~+ {associativity left precedence 140}
func +~+ (lhs: Int, rhs: Int) -> Int {
    println("\(lhs) + \(rhs)")
    return lhs + rhs
}
let sum = 1 +~+ 2 +~+ 3 // 1 + 2, 3 + 3

infix operator +~+ {associativity right precedence 140}
func +~+ (lhs: Int, rhs: Int) -> Int {
    println("\(lhs) + \(rhs)")
    return lhs + rhs
}
let sum = 1 +~+ 2 +~+ 3 // 2 + 3, 1 + 5

infix operator +~+ {associativity none precedence 140}
func +~+ (lhs: Int, rhs: Int) -> Int {
    println("\(lhs) + \(rhs)")
    return lhs + rhs
}
let sum = 1 +~+ 2 +~+ 3 // compile error

NSLayoutAttributeLeftMargin NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeRightMargin NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeTopMargin NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeBottomMargin NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeLeadingMargin NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeTrailingMargin NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeCenterXWithinMargins NS_ENUM_AVAILABLE_IOS(8_0),
NSLayoutAttributeCenterYWithinMargins NS_ENUM_AVAILABLE_IOS(8_0),

@property (nonatomic) UIEdgeInsets layoutMargins NS_AVAILABLE_IOS(8_0);
@property (nonatomic) BOOL preservesSuperviewLayoutMargins NS_AVAILABLE_IOS(8_0); // default is NO - set to enable pass-through or cascading behavior of margins from this view’s parent to its children
- (void)layoutMarginsDidChange NS_AVAILABLE_IOS(8_0);

- (CGSize)systemLayoutSizeFittingSize:(CGSize)targetSize NS_AVAILABLE_IOS(6_0);
- (CGSize)systemLayoutSizeFittingSize:(CGSize)targetSize 
        withHorizontalFittingPriority:(UILayoutPriority)horizontalFittingPriority
              verticalFittingPriority:(UILayoutPriority)verticalFittingPriority NS_AVAILABLE_IOS(8_0);

[view systemLayoutSizeFittingSize:targetSize]

[view systemLayoutSizeFittingSize:targetSize
    withHorizontalFittingPriority:UILayoutPriorityFittingSizeLevel
          verticalFittingPriority:UILayoutPriorityFittingSizeLevel]

UIKIT_EXTERN const CGSize UILayoutFittingCompressedSize NS_AVAILABLE_IOS(6_0);
UIKIT_EXTERN const CGSize UILayoutFittingExpandedSize NS_AVAILABLE_IOS(6_0);

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    SomeTableViewCell *protoCell = <#get a proto cell#>;
    [protoCell loadData:<#data#>];
    return [protoCell systemLayoutSizeFittingSize:(CGSize){CGRectGetWidth(tableView.frame), UILayoutFittingExpandedSize.height}].height;
}