             }
     }
     
-    func rac_fetchTextualMail(folder: String, uids: NSIndexSet) -> SignalProducer<FetchResult, PostalError> {
-        return rac_fetch(folder, uids: uids, flags: [ .structure, .fullHeaders ])
-            .flatMap(.Concat) { (fetchResult: FetchResult) -> SignalProducer<FetchResult, PostalError> in
+    func rac_fetchTextualMail(folder: String, uids: IndexSet) -> SignalProducer<FetchResult, PostalError> {
+        return rac_fetch(folder: folder, uids: uids, flags: [ .structure, .fullHeaders ])
+            .flatMap(.concat) { (fetchResult: FetchResult) -> SignalProducer<FetchResult, PostalError> in
                 let inlineElements = fetchResult.body?.allParts.filter { singlePart in
-                    if case .Some(.attachment) = singlePart.mimeFields.contentDisposition { return false }
+                    if case .some(.attachment) = singlePart.mimeFields.contentDisposition { return false }
                     return [ "text/html", "text/plain" ].contains("\(singlePart.mimeType)")
                     } ?? []
                 
-                return SignalProducer<SinglePart, PostalError>(values: inlineElements)
-                    .flatMap(.Merge) { (singlePart: SinglePart) -> SignalProducer<(String, MailData), PostalError> in
-                        return self.rac_fetchAttachment(folder, uid: fetchResult.uid, partId: singlePart.id).map { (singlePart.id, $0) }
+                return SignalProducer<SinglePart, PostalError>(inlineElements)
+                    .flatMap(.merge) { (singlePart: SinglePart) -> SignalProducer<(String, MailData), PostalError> in
+                        return self.rac_fetchAttachment(folder: folder, uid: fetchResult.uid, partId: singlePart.id).map { (singlePart.id, $0) }
                     }
                     .collect()
-                    .map { fetchResult.mergeAttachments(Dictionary(elements: $0)) }
+                    .map { fetchResult.mergeAttachments(attachments: Dictionary<String, MailData>($0)) }
             }
     }
 }
 
 private extension Dictionary {
-    init<S: SequenceType where S.Generator.Element == Element>(elements: S) {
+    init<S: Sequence>(_ seq: S) where S.Iterator.Element == (Key, Value) {
+        self.init()
+        for (k, v) in seq {
+            self[k] = v
+        }
+    }
+    
+    init<S: Sequence>(elements: S) where S.Iterator.Element == Element {
         self.init()
         for (k, v) in elements {
             self[k] = v

        return FetchResult(uid: uid,
                           header: header,
                           flags: flags,
                           body: body?.mergeAttachments(attachments),
                           rfc822Size: rfc822Size,
                           internalDate: internalDate,
                           gmailThreadId: gmailThreadId,

        return SignalProducer<MailData, PostalError> { observer, disposable in
            self.fetchAttachments(folder, uid: uid, partId: partId,
                onAttachment: { data in
                    observer.send(value: data)
                },
                onComplete: { error in
                    if let error = error {
                        observer.send(error: error)
                    } else {
                        observer.sendCompleted()
                    }
