Swift泛型约束中的元组类型

Question

I'm trying to write a generic function in Swift with the constraint that the parameter must be a sequence of pairs (which I'm going to turn into a dictionary). Is this possible? I've tried a number of variations on the following, but the compiler doesn't like any of them.

func foo<K, V, S: SequenceType where S.Generator.Element == (K,V)>(xs: S) { //...}

Answer 1

Not a direct answer to your question, but if you want to create a dictionary then you could define your function as an extension method to Dictionary and use the fact that Dictionary defines

typealias Element = (Key, Value)

Then your method declaration could be

extension Dictionary {
    func foo<S : SequenceType where S.Generator.Element == Element>(xs : S) {
        //...
    }
}

To create a dictionary from the tuples, an init method might be more appropriate, for example

extension Dictionary {

    init<S : SequenceType where S.Generator.Element == Element>(xs : S) {

        self.init()
        var gen = xs.generate()
        while let (key, value) : Element = gen.next() {
            self[key] = value
        }
    }
}

Usage:

let d = Dictionary(xs: [("a", 1), ("b", 2)])
println(d) // [b: 2, a: 1]

Note: The enumation via generate() and next() in above code is a workaround for the problem that, for some reason

for (key, value) in xs { }

does not compile. Compare Implementing Set.addSequence in Swift .

---

Update: As of Swift 2/Xcode 7, the above method can be simplified to

extension Dictionary {

    init<S : SequenceType where S.Generator.Element == Element>(xs : S) {
        self.init()
        xs.forEach { (key, value) in
            self[key] = value
        }
    }
}

Answer 2

It looks like a compiler bug to me.

Problem here is that: you cannot use tuple type directly in generic parameters.

As @MartinR said in his answer, it works if we use typealias ed tuple type. But of course, we cannot declare generic typealias in global context.

For example, this compiles and works:

struct Foo<K,V> {
    typealias Element = (K,V)
    static func foo<S:SequenceType where S.Generator.Element == Element>(xs:S) {
        var gen = xs.generate()
        while let (k,v): Element = gen.next() {
            println((k,v))
        }
    }
}

Foo.foo(["test":"foo", "bar": "baz"])

One more idea is something like this:

struct SequenceOfTuple<K,V>: SequenceType {

    typealias Element = (K,V)

    let _generate:() -> GeneratorOf<Element>

    init<S:SequenceType where S.Generator.Element == Element>(_ seq:S) {
        _generate = { GeneratorOf(seq.generate()) }
    }
    func generate() -> GeneratorOf<Element> {
        return _generate()
    }
}

func foo<K,V>(xs:SequenceOfTuple<K,V>) {
    for (k, v) in xs {
        println((k,v))
    }
}

foo(SequenceOfTuple(["test":"foo", "bar": "baz"]))

In this case, you must wrap the sequence of tuple with SequenceOfTuple type, then pass it to foo() .

Hmm...

Answer 3

You can use a struct with a subscript and store the results in a Dictionary:

struct Matrix<K:Hashable, V> {

    var container:[K:[K:V]] = [:]

    subscript(x:K, y:K) -> V? {
        get {
            return container[x]?[y]
        }
        set (value) {
            if container[x] == nil {
                container[x] = [:]
            }
            container[x]![y] = value
        }
    }
}

var matrix = Matrix<Int, String>()
matrix[11,42] = "Hello World"

println("(11,42): \(matrix[11,42])") // Optional("Hello World")
println("(1,3): \(matrix[1,3])")     // nil