         case let .array(type): return [.array] + type.characters
         case let .dictionary(type): return [.dictionaryEntryStart] + type.characters + [.dictionaryEntryEnd]
         case let .struct(type): return [.structStart] + type.elements.reduce([], { $0 + $1.characters }) + [.structEnd]
-        //case .variant: fatalError("No idea")
+        case .variant: return [.variant]
         }
+    }
+}
+
+public extension Collection where Element == DBusSignature.ValueType {
+    
+    var characters: [DBusSignature.Character] {
+        
+        return self.reduce([], { $0 + $1.characters })
+    }
+}
+
+public extension String {
+    
+    init(_ signature: [DBusSignature.Character]) {
+        
+        self = signature.reduce("", { $0 + $1.rawValue })
     }
 }
 

        
        /// Dictionary
        case dictionary(ValueType)
    }
}

extension DBusSignature.ValueType: Equatable {
    
    public static func == (lhs: DBusSignature.ValueType, rhs: DBusSignature.ValueType) -> Bool {
        
        switch (lhs, rhs) {
            
        case (.byte, .byte): return true
        // TODO: Equality
        default:
            return false
        }
    }
}


    
    public var rawValue: String {
        
        return String(self.elements)
    }
}
