Travailler avec des points de code Unicode en Swift

//Swift 3.0  
//This struct is an array of UInt32 to hold Unicode scalar values
struct ScalarString: Sequence, Hashable, CustomStringConvertible {
private var scalarArray: [UInt32] = []
init() {
//does anything need to go here?
    }
init(_ character: UInt32) {
self.scalarArray.append(character)
}
init(_ charArray: [UInt32]) {
for c in charArray {
self.scalarArray.append(c)
}
}
init(_ string: String) {
for s in string.unicodeScalars {
self.scalarArray.append(s.value)
}
}
//Generator in order to conform to SequenceType protocol
    //(to allow users to iterate as in `for myScalarValue in myScalarString` { ... })

//func generate() -> AnyIterator<UInt32> {
    func makeIterator() -> AnyIterator<UInt32> {
let nextIndex = 0
return AnyIterator {
if (nextIndex > self.scalarArray.count-1) {
return nil
}
return self.scalarArray[nextIndex + 1]
}
}
//append
    mutating func append(scalar: UInt32) {
self.scalarArray.append(scalar)
}
mutating func append(scalarString: ScalarString) {
for scalar in scalarString {
self.scalarArray.append(scalar)
}
}
mutating func append(string: String) {
for s in string.unicodeScalars {
self.scalarArray.append(s.value)
}
}
//charAt
    func charAt(index: Int) -> UInt32 {
return self.scalarArray[index]
}
//clear
    mutating func clear() {
self.scalarArray.removeAll(keepingCapacity: true)
}
//contains
    func contains(character: UInt32) -> Bool {
for scalar in self.scalarArray {
if scalar == character {
return true
}
}
return false
}
//description (to implement Printable protocol)
    var description: String {
var string: String = ""
for scalar in scalarArray {
string.append(String(describing: UnicodeScalar(scalar))) //.append(UnicodeScalar(scalar)!)
        }
return string
}
//endsWith
    func endsWith() -> UInt32? {
return self.scalarArray.last
}
//insert
    mutating func insert(scalar: UInt32, atIndex index: Int) {
self.scalarArray.insert(scalar, at: index)
}
//isEmpty
    var isEmpty: Bool {
get {
return self.scalarArray.count == 0
}
}
//hashValue (to implement Hashable protocol)
    var hashValue: Int {
get {
//DJB Hash Function
            var hash = 5381
for i in 0 ..< scalarArray.count {
hash = ((hash << 5) &+ hash) &+ Int(self.scalarArray[i])
}
/*
for i in 0..< self.scalarArray.count {
hash = ((hash << 5) &+ hash) &+ Int(self.scalarArray[i])
}
*/
return hash
}
}
//length
    var length: Int {
get {
return self.scalarArray.count
}
}
//remove character
    mutating func removeCharAt(index: Int) {
self.scalarArray.remove(at: index)
}
func removingAllInstancesOfChar(character: UInt32) -> ScalarString {
var returnString = ScalarString()
for scalar in self.scalarArray {
if scalar != character {
returnString.append(scalar: scalar) //.append(scalar)
            }
}
return returnString
}
//replace
    func replace(character: UInt32, withChar replacementChar: UInt32) -> ScalarString {
var returnString = ScalarString()
for scalar in self.scalarArray {
if scalar == character {
returnString.append(scalar: replacementChar) //.append(replacementChar)
            } else {
returnString.append(scalar: scalar) //.append(scalar)
            }
}
return returnString
}
//func replace(character: UInt32, withString replacementString: String) -> ScalarString {
    func replace(character: UInt32, withString replacementString: ScalarString) -> ScalarString {
var returnString = ScalarString()
for scalar in self.scalarArray {
if scalar == character {
returnString.append(scalarString: replacementString) //.append(replacementString)
            } else {
returnString.append(scalar: scalar) //.append(scalar)
            }
}
return returnString
}
//set (an alternative to myScalarString = "some string")
    mutating func set(string: String) {
self.scalarArray.removeAll(keepingCapacity: false)
for s in string.unicodeScalars {
self.scalarArray.append(s.value)
}
}
//split
    func split(atChar splitChar: UInt32) -> [ScalarString] {
var partsArray: [ScalarString] = []
var part: ScalarString = ScalarString()
for scalar in self.scalarArray {
if scalar == splitChar {
partsArray.append(part)
part = ScalarString()
} else {
part.append(scalar: scalar) //.append(scalar)
            }
}
partsArray.append(part)
return partsArray
}
//startsWith
    func startsWith() -> UInt32? {
return self.scalarArray.first
}
//substring
    func substring(startIndex: Int) -> ScalarString {
//from startIndex to end of string
        var subArray: ScalarString = ScalarString()
for i in startIndex ..< self.length {
subArray.append(scalar: self.scalarArray[i]) //.append(self.scalarArray[i])
        }
return subArray
}
func substring(startIndex: Int, _ endIndex: Int) -> ScalarString {
//(startIndex is inclusive, endIndex is exclusive)
        var subArray: ScalarString = ScalarString()
for i in startIndex ..< endIndex {
subArray.append(scalar: self.scalarArray[i]) //.append(self.scalarArray[i])
        }
return subArray
}
//toString
    func toString() -> String {
let string: String = ""
for scalar in self.scalarArray {
string.appending(String(describing:UnicodeScalar(scalar))) //.append(UnicodeScalar(scalar)!)
        }
return string
}
//values
    func values() -> [UInt32] {
return self.scalarArray
}
}
func ==(left: ScalarString, right: ScalarString) -> Bool {
if left.length != right.length {
return false
}
for i in 0 ..< left.length {
if left.charAt(index: i) != right.charAt(index: i) {
return false
}
}
return true
}
func +(left: ScalarString, right: ScalarString) -> ScalarString {
var returnString = ScalarString()
for scalar in left.values() {
returnString.append(scalar: scalar) //.append(scalar)
    }
for scalar in right.values() {
returnString.append(scalar: scalar) //.append(scalar)
    }
return returnString
}