I'm attempting to create a constrained extension on Dictionary that only applies to String-keyed dictionaries.

Constrained Extension Attempt.swift

import Foundation

extension Dictionary where Key:String {
    func methodThatOnlyMakesSenseWhenKeysAreStrings() -> [Key : Value] {
        var resultDict = [Key : Value]
        for key in self.keys {
            let reversedKey = String(key.characters.reverse())
            resultDict[reversedKey] = self[key]
        }
        return resultDict
    }
}

let testDict = ["one" : 1, "two" : "dos", "three" : NSNumber(char: 3)]
let reverseDict = testDict.methodThatOnlyMakesSenseWhenKeysAreStrings() 
// Error: [String:NSObject] doesn't have member named methodThatOnlyMakesSenseWhenKeysAreStrings

Look at the type of testDict. It's NSDictionary not Dictionary.

protocol StringType {}
extension String: StringType {}

public extension SequenceType {
    func mapDo(p: (Self.Generator.Element) -> Void) {
        for x in self {p(x)}
    }
}

extension Dictionary where Key:StringType {
    func methodThatOnlyMakesSenseWhenKeysAreStrings() -> [String:Value] {
        var resultDict = [String:Value]()
        self.mapDo({(key, value) in
            let reversedKey = String(String(key).characters.reverse())
            resultDict[reversedKey] = self[key]})
        return resultDict
    }
}

But I like this better

protocol Reversible {
    var reversed : Self {get}
}

extension String: Reversible {
    var reversed : String {return String(self.characters.reverse())}
}


public extension SequenceType {
    func mapDo(p: (Self.Generator.Element) -> Void) {
        for x in self {p(x)}
    }
}

extension Dictionary where Key:Reversible {
    func methodThatOnlyMakesSenseWhenKeysAreStrings() -> [Key:Value] {
        var resultDict = [Key:Value]()
        self.mapDo({(key, value) in
            resultDict[key.reversed] = self[key]})
        return resultDict
    }
}

Thank you, Erica! I'm going to dive into this and try to understand it better.

Ahh, I see. The extension constraint can only specify protocols, not types.