簡評：看看這段 Swift 代碼：
let link:LinkedList = [1,2,3,4,5,6,7,8]
link 并不是一個數組哦，看完這篇文章你就懂了。

自2012年以來，可以使用 “literal” 表達式初始化NSDictionary，NSArray，NSNumber或NSString。

NSNumber *numb = @1;
NSArray *things = @[@3,@45,@65];
NSDictionary *map = @{@"Florida" : @1 , @"Nevada" : @6 };
NSString *greet = @"Hello there!";

這種 “literal” 表達式讓代碼變得更加簡潔。

你有沒有想過使用 “literal” 表達式來初始化自己的數據結構。

Swift 中提供了 “ExpressibleBy _____” 這類協議：

• Expressible By Array Literal
• Expressible By Boolean Literal
• Expressible By Dictionary Literal
• Expressible By Float Literal
• Expressible By Integer Literal
• Expressible By String Literal
• Expressible By Unicode Scalar Literal
• Expressible By Extended Grapheme Cluster Literal

可以使用 “literal” 表達式來初始化自己的數據結構，可以看看下面的例子，如何使用 “literal” 表達式來構建自己的數據結構。

Array-ish 數據結構

來看看 Swift 中的例子， [1,2,3,4,5,6,7,8] 這很可能用于初始化一個 Array。但是！他也可以用于初始化成其他的數據結構。

鏈表

下面這段代碼就是介紹如何使用 Array literal 來初始化一個鏈表:

class LinkedList<T> : ExpressibleByArrayLiteral, CustomDebugStringConvertible {
    var debugDescription: String {
        get {
            var accum = ""
            guard let startNode = self.head else { return "(empty list)" }
            accum += startNode.debugDescription
            var currentNode:Node = startNode
            while(true) {
                guard let node = currentNode.next else { break }
                accum += node.debugDescription
                currentNode = node
            }
            return accum
        }
    }
    var head:Node?
    var tail:Node?
    typealias Element = T
    required public init(arrayLiteral elements:Element...) {
        for i in elements {
            if self.head == nil {
                self.head = Node(data:i)
                self.tail = self.head
                continue
            }
            let newNode = Node(data:i)
            self.tail?.next = newNode
            self.tail = newNode
        }
    }
    class Node : CustomDebugStringConvertible {
        var debugDescription: String {
            get {
                var accum = "(\(data))->"
                if next == nil {
                    accum += "*"
                }
                return accum
            }
        }
        var next:Node?
        var data:T
        init(data:T) {
            self.data = data
        }
    }
}
let link:LinkedList<Int> = [1,2,3,4,5,6,7,8]
print(link)   // Prints (1)->(2)->(3)->(4)->(5)->(6)->(7)->(8)->*

LinkedList 類遵從 ExpressibleByArrayLiteral 協議，實現 init(arrayLiteral: Self.Element...) 這個初始化方法， 那么我們就可以直接使用 Array literal 賦值進行初始化。

let link:LinkedList<Int> = [1,2,3,4,5,6,7,8] 

注意：必須使用 Array literal 來賦值，而不能用一個數組賦值，因為這是兩個不同的東西，例如：

let someArray = [1,2,3,4]
let list:LinkedList<Int> = someArray  // 這段代碼會報錯。

堆棧

struct ConvertibleStack<T> : ExpressibleByArrayLiteral, CustomDebugStringConvertible {

    var debugDescription: String {
        get {
            return "Stack: \(storage)"
        }
    }
    typealias Element = T
    private var storage: [T] = []

    public init(arrayLiteral elements:Element...) {
        self.storage = elements
    }

    mutating func push(item:T) {
        storage.insert(item, at: 0)
    }

    mutating func pop() -> T? {
        guard storage.count > 0 else { return nil }
        return storage.remove(at: 0)
    }
}

隊列

struct ConvertibleStack<T> : ExpressibleByArrayLiteral, CustomDebugStringConvertible {

    var debugDescription: String {
        get {
            return "Stack: \(storage)"
        }
    }
    typealias Element = T
    private var storage: [T] = []

    public init(arrayLiteral elements:Element...) {
        self.storage = elements
    }

    mutating func push(item:T) {
        storage.insert(item, at: 0)
    }

    mutating func pop() -> T? {
        guard storage.count > 0 else { return nil }
        return storage.remove(at: 0)
    }
}

最后，如果正確的使用 litera 初始化可以提高可讀性。這種方法適用于樹或有向圖嗎？我把這個探索留給了讀者 : ) Happy Hacking!

原文：Express Yourself Swift Style

推薦閱讀：

• Swift 的 Enums 是 “Sum” 類型，這讓一切變得更有趣
• 極光開源項目：「Aurora UI」，一個通用 IM 聊天 UI 組件，首版即支持 swift。