Swift code:

public enum Token {
  public case identifier(Substring)
  public case integer(Substring)
  public case comma
  public case lparen
  public case rparen
  // ...
  public case badCharacter(Character)
  public case eof
}

public struct Lexer {
  private var contents: Substring
  public var currentToken: Token

  public init(contents: Substring) {
    self.contents = contents
    currentToken = .eof
    lex()
  }

  public mutating func consume() {
    lex()
  }

  public mutating func consumeIf(predicate: (Token) -> Bool) -> Bool {
    guard !predicate(currentToken) { return false }
    lex()
    return true
  }

  public mutating func consumeIf(exactly token: Token) -> Bool {
    return consumeIf { $0 == token }
  }

  private mutating func lex() {
    contents = contents.dropWhile { $0.isWhitespace }
    guard let c = contents.first { currentToken = .eof; return }
    switch c {
    case _ where c.isDigit:
      let idx = contents.firstIndex { !$0.isDigit } ?? contents.endIndex
      currentToken = .integer(contents.prefix(upTo: idx))
      contents = contents.suffix(from: idx)
    case _ where c.isLetter || c == "_":
      let idx = contents.firstIndex { !$0.isLetter && !$0.isDigit && $0 != "_" } ?? contents.endIndex
      currentToken = .identifier(contents.prefix(upTo: idx))
      contents = contents.suffix(from: idx)    
    case ",":
      currentToken = .comma
      contents = contents.dropFirst(1)
    case "(":
      currentToken = .lparen
      contents = contents.dropFirst(1)
    case ")":
      currentToken = .rparen
      contents = contents.dropFirst(1)
    // ...
    case _:
      currentToken = .badCharacter(c)
      contents = contents.dropFirst(1)
    }
  }
}

enum ParserError: Error {
  case unexpected(Token)
  case integerOutOfRange(Substring)
}

public struct Parser {
  private var lexer: Lexer

  public init(contents: Substring) {
    lexer = Lexer(contents: contents)
  }

  public mutating func expect(exactly expected: Token) throws {
    if !lexer.consumeIf(exactly: expected) {
      throw ParserError.unexpected(lexer.currentToken)
    }
  }

  public mutating func parseInt() throws -> Int {
    guard case .integer(let string) = lexer.currentToken {
      throw ParserError.unexpected(lexer.currentToken)
    }
    lexer.consume()
    guard let result = Int(string) {
      throw ParserError.integerOutOfRange(string)
    }
    return result
  }

  public mutating func parseCommaSeparatedList<T>(elementParser: (inout Parser) throws -> T) throws -> [T] {
    try expect(exactly: .lparen)
    var list = [T]()
    if lexer.currentToken != .rparen {
      repeat {
        list.append(try elementParser(&self))
      } while lexer.consumeIf(exactly: .comma)
    }
    try expect(exactly: .rparen)
    return list
  }

  public mutating func parseIntList() throws -> [Int] {
    return parseCommaSeparatedList { $0.parseInt() }
  }
}