我想在 Swift 中创建一个不可变但可以完全替换的函数式编程风格的数组。

我知道我可以用这种方式创建它们:

var mutable   = [1,2,3] // can change reference, add, remove, etc
let immutable = [4,5,6] // cannot replace reference or add, remove, etc

我想要不变性的属性，但仍然能够更改我的变量指向的不可变数组。例如，我希望它失败:

myArr.append(42) // fails. immutable array

但我希望这能成功:

// Desired behavior:
// Multiply each element in the immutable array by 2
// Return a new immutable array, assigned to the old var
immutable = immutable.map { $0 * 2 } // ERROR: can't replace immutable ref

类似，但不是答案:

• ways to make arrays and collections, but not the kind I'm asking about
• previous language issue that made arrays partially mutable

最佳答案

我不知道有什么方法可以使用内置的 Array 类型来实现。 您可以做的是定义自定义 ConstantArray 类型 其中包含一个数组并且只有不可变的访问器方法 (它们都被转发到包含的数组):

struct ConstantArray<T> {
    private let elements : [T]

    // Create with an empty array.
    init() {
        elements = []
    }

    // Create with some sequence, e.g.
    //     let constArray = ConstantArray([1, 2, 3])
    init<S : SequenceType where S.Generator.Element == T>(_ s: S) {
        elements = Array(s)
    }

    // Read-only computed property to get the elements.
    var array : [T]  {
        return elements
    }

    // Some properties you might want to implement:
    var count: Int { return elements.count }
    var isEmpty: Bool { return elements.isEmpty }
    var first: T? { return elements.first }
    var last: T? { return elements.last }

}

extension ConstantArray : ArrayLiteralConvertible {
    // Create with an array literal, e.g.
    //     let constArray : ConstantArray = [1, 2, 3]
    init(arrayLiteral array: T...) {
        elements = array
    }
}

// Implement sequence prototol, e.g. for enumeration:
//     for elem in myConstantArray { ... }
extension ConstantArray : SequenceType {
    func generate() -> IndexingGenerator<[T]> {
        return elements.generate()
    }
}

// Implement read-only subscripting, e.g.
//     let elem = myConstantArray[1]
extension ConstantArray: CollectionType {
    var startIndex : Int { return elements.startIndex }
    var endIndex : Int { return elements.endIndex }

    subscript(index: Int) -> T {
        return elements[index]
    }
}

extension ConstantArray : Printable {
    var description: String { return elements.description }
}

当然这是不同的类型，但是通过实现 SequenceType 和 CollectionType 可以非常相似地使用。 示例:

var myArr : ConstantArray = [1, 2, 3]

myArr.append(42)   // error: 'ConstantArray<Int>' does not have a member named 'append'
myArr[2] = 3       // error: cannot assign to the result of this expression
myArr.array[2] = 3 // error: cannot assign to the result of this expression

myArr = [4, 5, 6] // succeeds
println(myArr) // [4, 5, 6]
for elem in myArr {
    println(elem)
}

对于映射，可以使用全局的map()函数 (或 Array 的 map() 方法)并将结果转换回 ConstantArray:

myArr = ConstantArray(map(myArr) { $0 * 2 })
myArr = ConstantArray(myArr.array.map { $0 * 2 })

或者你为 ConstantArray 实现一个 map() 方法:

extension ConstantArray {
    func map<U>(transform: (T) -> U) -> ConstantArray<U> {
        return ConstantArray<U>(elements.map(transform))
    }
}

并将其用作

myArr = myArr.map { 2 * $0 }

以同样的方式，其他方法如 filter() 和 sorted() 可以为 ConstantArray 实现。

关于swift - 不可变的 `var` 数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30554414/