For one reason or another, we find ourselves writing small scanners and parsers quite often. Sometimes we parse a specific file format, or a small expression language, or just a file name that conforms to a certain naming scheme.

One approach is to use the Scanner class from Foundation (it used to be called NSScanner ). A Scanner instance stores the scanned String and a scan location, which is the position in the string. For example, scanning a single character just returns the character at the current scan location and increases the scan location.

In pure Swift, there's another type that stores a String and an offset into that String : Substring . Instead of using a scanner, we could write mutating methods on Substring . As an illustration, here are three such methods. The first matches a character that matches a certain condition, the second scans exactly count characters, and the last scans a specific prefix:

								extension Substring {
    mutating func scan(_ condition: (Element) -> Bool) -> Element? {
        guard let f = first, condition(f) else { return nil }
        return removeFirst()
    }

    mutating func scan(count: Int) -> Substring? {
        let result = prefix(count)
        guard result.count == count else { return nil }
        removeFirst(count)
        return result
    }

    mutating func scan<C>(prefix: C) -> Bool where C: Collection, C.Element == Character {
        guard starts(with: prefix) else { return false }
        removeFirst(prefix.count)
        return true
    }
}

							

To use this with strings, we first need to make a mutable Substring out of a String , and then we can call the scan method:

								var remainder = "value: 123"[...]
if remainder.scan(prefix: "value: "),
   let firstDigit = remainder.scan({ "0123456789".contains($0) }) {
  print(firstDigit)
}

							

You can write a whole bunch of these scanning methods, there is no need for an extra Scanner type. You can even write "higher-order" scanners, like this:

								extension Substring {
  mutating func many<A>(until end: Character, _ f: (inout Substring) throws -> A, separator: (inout Substring) throws -> Bool) throws -> [A] {
    // ... left as an exercise
  }
}

							

So far, we could have done similar things with a Scanner . However, one of the fun things about Swift is that the code we write is actually far more generic! Instead of defining it on Substring , we can define it on any Collection that supports removeFirst . Reviewing the method's definition , we learn that it exists on any collection that has itself as a Subsequence . This means we only have to change the definition of the method, but not the method body:

								extension Collection where SubSequence == Self {
    mutating func scan(_ condition: (Element) -> Bool) -> Element? {
        guard let f = first, condition(f) else { return nil }
        return removeFirst()
    }

    mutating func scan(count: Int) -> Self? {
        let result = prefix(count)
        guard result.count == count else { return nil }
        removeFirst(count)
        return result
    }
}

extension Collection where SubSequence == Self, Element: Equatable {
    mutating func scan<C>(prefix: C) -> Bool where C: Collection, C.Element == Element {
        guard starts(with: prefix) else { return false }
        removeFirst(prefix.count)
        return true
    }
}

							

Now we can use our scan method on many other types as well, most notably ArraySlice and Data . For example, we can use it to parse the beginning of a GIF header:

								var t = try! Data(contentsOf: URL(string: "https://media.giphy.com/media/gw3IWyGkC0rsazTi/giphy.gif")!)[...]
guard t.scan(prefix: [71,73,70]), // GIF
    let version = t.scan(count: 3), // 87a or 89a
    let width = t.scan(count: 2),
	let height = t.scan(count: 2)
    else {
    fatalError()
}

print(version, width, height)

							

For further inspiration, see this gist by Michael Ilseman .

In Swift Talk Episode 78 (a public episode), we show how to work with Swift's String and Substring types by writing a simple CSV parser.

To support our work you can subscribe , or give someone a gift .