Letters.swift

// CONSTRUCTING ALPHABET ARRAY

// This my favorite because it's easily used with any character set
extension NSCharacterSet {
    var members: [String] {
        let unichars = Array(unichar(0)..<unichar(128)).filter({self.characterIsMember($0)})
        return unichars.map({String(UnicodeScalar($0))})
    }
}

let letterMembers = NSCharacterSet.uppercaseLetterCharacterSet().members

// This returns a generator rather than an array
let letterGenerator: AnyGenerator<String> = {
    var letters = NSCharacterSet.uppercaseLetterCharacterSet().members
    return anyGenerator {return letters.count > 0 ? letters.removeFirst() : nil} }()


// Decompose string into component character strings
let charLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".characters.map({String($0)})

// In map we trust. Is an issue for anything non-contiguous
let uniLetters = (65..<(65+26)).map({String(UnicodeScalar($0))})

// Kametrixom writes: You shouldn't use removeFirst() as its O(n) on arrays, you can just return the letters.generate() Gen which is definitely O(1)
// https://twitter.com/Kametrixom/status/643305445814353920
var letterGenerator2: IndexingGenerator<[String]> {
    return NSCharacterSet.uppercaseLetterCharacterSet().members.generate()}

// Norio Nomura writes: Swift can infer UnicodeScalar as following
// https://twitter.com/norio_nomura/status/643280736552816640
let alphabet = ("A"..."Z" as Range).map { String($0) }

// Nate Cook writes: If we extend UnicodeScalar to conform to ForwardIndexType, we can create and map a Range
// https://t.co/coms3wWFIr 
// https://twitter.com/nnnnnnnn/status/643268606315266049
// If we extend UnicodeScalar to conform to ForwardIndexType, we can create and map a Range.
extension UnicodeScalar: ForwardIndexType {
public func successor() -> UnicodeScalar {
return UnicodeScalar(value + 1)
    }
}
let alphabet = ("A"..."Z" as Range).map { String($0) }

ZForKic.swift

// Some stuff for 3.0

import Foundation

// CONSTRUCTING ALPHABET ARRAY
// This my favorite because it's easily used with any character set
extension CharacterSet {
    /// Return set members
    public var members: [String] {
        let scalars = Array(unichar(0)..<unichar(1024))
            .map({ UnicodeScalar($0)! })
            .filter({ contains($0) })
        return scalars.map({ String($0) })
    }
}

let letterMembers = CharacterSet.uppercaseLetters.members

// This returns a generator rather than an array
let letterGenerator: AnyIterator<String> = {
    var letters = CharacterSet.uppercaseLetters.members
    return AnyIterator {
        return letters.count > 0 ? letters.removeFirst() : nil
    }
}()

// Decompose string into component character strings
let charLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".characters.map({ String($0) })

// No.
// let charsx = Array("ABCDEFGHIJKLMNOPQRSTUVWXYZ".utf8).map(String.init)

// In map we trust. Is an issue for anything non-contiguous
let uniLetters = (65..<(65+26))
    .map(UnicodeScalar.init)
    .map({ String($0) })

// Kametrixom writes: You shouldn't use removeFirst() as its O(n) on arrays, you can just return the letters.generate() Gen which is definitely O(1)
// https://twitter.com/Kametrixom/status/643305445814353920
var letterGenerator2: IndexingIterator<[String]> {
    return CharacterSet.uppercaseLetters.members.makeIterator()
}


// Norio Nomura writes: Swift can infer UnicodeScalar as following
// https://twitter.com/norio_nomura/status/643280736552816640
// let alphabet = ("A" ... "Z" as Range).map { String($0) }
// No longer works

//// Nate Cook writes: If we extend UnicodeScalar to conform to ForwardIndexType, we can create and map a Range
//// https://t.co/coms3wWFIr
//// https://twitter.com/nnnnnnnn/status/643268606315266049
//// If we extend UnicodeScalar to conform to ForwardIndexType, we can create and map a Range.
//extension UnicodeScalar: Comparable {
//    public func successor() -> UnicodeScalar {
//        return UnicodeScalar(value + 1)!
//    }
//}
// let alphabet = ("A" ... "Z" as Range).map { String($0) }

Can clean it up a bit to this:

extension NSCharacterSet {
    var members: [String] {
        let unichars = Array(unichar(0)..<unichar(128)).filter(characterIsMember)
        return unichars.map { String(UnicodeScalar($0)) }
    }
}

let letterMembers = NSCharacterSet.uppercaseLetterCharacterSet().members

// This returns a generator rather than an array
let letterGenerator: AnyGenerator<String> = {
    var letters = NSCharacterSet.uppercaseLetterCharacterSet().members
    return anyGenerator { letters.count > 0 ? letters.removeFirst() : nil} }()


// Decompose string into component character strings
let charLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".characters.map { String($0) }

// In map we trust. Is an issue for anything non-contiguous
let uniLetters = (65..<(65+26)).map { String(UnicodeScalar($0)) }

if you could .map to String.init better you could have thing.map(UnicodeScalar.init).map(String.init) instead of thing.map { String(UnicodeScalar($0)) }, not sure if that's an improvement though.