     case `default`
 }
 
+/**
+ Generates a hash value for one or more hashable values.
+ */
 private func hash<H: Hashable>(_ hashables: H...) -> Int {
     // djb2 hash algorithm: http://www.cse.yorku.ca/~oz/hash.html
     // &+ operator handles Int overflow

        }
    }
    
    public static func filter<T, N: Hashable, C: Hashable>(type: T.Type, name: N, container: C) -> [Key] {
        return filter(type: String(reflecting: type), name: name, container: container)
    }
    
    public static func filter<T, N: Hashable>(type: T.Type, name: N) -> [Key] {
        return filter(type: String(reflecting: type), name: name, container: nil)
    }
    
    public static func filter<T, C: Hashable>(type: T.Type, container: C) -> [Key] {
        return filter(type: String(reflecting: type), name: nil, container: container)
    }
    
    public static func filter<N: Hashable, C: Hashable>(name: N, container: C) -> [Key] {
        return filter(type: nil, name: name, container: container)
    }
    
    public static func filter<N: Hashable>(name: N) -> [Key] {
        return filter(type: nil, name: name, container: nil)
    }
    
    public static func filter<C: Hashable>(container: C) -> [Key] {
        return filter(type: nil, name: nil, container: container)
    }

    public static var keys: [Key] {
        return lock.read { Array(registrations.keys) }
    }
    
    public static func unregister(key: Key) {
        unregister(keys: [key])
    }
    
    public static func unregister<K: Sequence>(keys: K) where K.Iterator.Element == Key {
        lock.write {
            registrations = registrations.filter{ keys.contains($0.key) }.dictionary { $0 }
        }
    }
    
    public static func unregister() {
        unregister(keys: keys)
    }
}



/**
 A unique key under which to register a block in Guise.
*/
public struct Key: Hashable {
    public let type: String
