This document discusses parsing and parsers. It introduces parsing as breaking a string into tokens through lexing and extracting meaning through parsing. It then defines a Parser type in Swift and provides some basic building blocks like Parser.result(), Parser.zero(), and Parser.item(). It shows how parsers can be combined using functions like bind() and satisfy() to parse characters, words, and make choices. Finally, it mentions some references on monadic parser combinators.

1. Parsing(Swi+ly

2. Parsing
Lexing'(Tokenizing)
Parsing((Extrac.ng(meaning)

3. What%is%the%Type%of%a%parser?

4. Parsing(an(Int

5. String'(>'Int

6. String'(>'(Int,'remainder:'String)

7. String'(>'(Int,'remainder:'String)?

8. <ValueType>+String+2>+(ValueType,+remainder:+
String)?

9. struct Parser<ValueType> {
let apply:(String) -> (ValueType, String)?
}

10. struct Parser<ValueType> {
typealias Function = (String) -> (ValueType, String)?
let apply:Function
init(apply: Function) {
self.apply = apply
}
}

12. Building(Blocks
Parser.result()
Parser.zero()
Parser.item()

13. Parser.result()
static func result(value:ValueType) -> Parser {
return Parser { (input) in
return (value, remainder:input)
}
}

14. Parser.zero()
static func zero() -> Parser {
return Parser { (input) in
return nil
}
}

15. Parser.item()
static func item() -> Parser<Character> {
return Parser<Character> { (input) in
let firstIndex = input.startIndex
if firstIndex == input.endIndex {
return nil
} else {
return (input[firstIndex], remainder: String(dropFirst(input)))
}
}
}

16. Let$Our$Parsers$Combine!

17. bind
func bind<T, U>(parserT:Parser<T>, lift:(T -> Parser<U>)) -> Parser<U> {
return Parser<U> { (input) in
if let (theT, theRemainder) = parserT.apply(input) {
return lift(theT).apply(theRemainder)
} else {
return nil
}
}
}

18. sa#sfy
func satisfy(predicate:(Character -> Bool)) -> Parser<Character> {
return bind(Parser<Character>.item()) { theChar in
if predicate(theChar) {
return Parser.result(theChar)
} else {
return Parser.zero()
}
}
}

19. char
func char(x:Character) -> Parser<Character> {
return satisfy { $0 == x }
}

20. func charIn<CharSeq: SequenceType where
CharSeq.Generator.Element == Character>
(x:CharSeq) -> Parser<Character> {
return satisfy { Set(x).contains($0) }
}

21. let digit:Parser<Character> = satisfy { "0"..."9" ~= $0 }
let lower:Parser<Character> = satisfy { "a"..."z" ~= $0 }
let upper:Parser<Character> = satisfy { "A"..."Z" ~= $0 }

22. I"Said""Let"Our"Parsers"Combine!"
let nsParser:Parser<String> = bind(char("N")) { (theLetterN) in
bind(char("S")) { (theLetterS) in
Parser<String>.result(String([theLetterN, theLetterS]))
}
}
nsParser.apply("NS")
nsParser.apply("AB")

23. a"small"detour
extension Optional {
internal func bind<U>(f: T -> U?) -> U? {
if let x = self {
return f(x)
} else {
return nil
}
}
}
func headAndTail(input:String) -> (head:Character, tail:String)? {
return first(input).bind { head in
return (head:head, tail:String(dropFirst(input)))
}
}

24. Words!
func word(x:String) -> Parser<String> {
if let found = headAndTail(x) {
return bind(char(found.head)) { (a:Character) in
return bind(word(found.tail)) { (b:String) in
return Parser<String>.result(x)
}
}
} else {
return Parser<String>.result(x)
}
}

25. Choice
func choice<T>(lhs:Parser<T>, rhs:Parser<T>) -> Parser<T> {
return Parser { (input) in
if let leftParse = lhs.apply(input) {
return leftParse
} else {
return rhs.apply(input)
}
}
}

26. Parse&you&a&Monad

27. Monadic(Parser(Combinators
Graham&Hu)on&and&Erik&Meijer
• h#p://www.cs.no#.ac.uk/~gmh/monparsing.pdf)
Parsec:(Direct(Style(Monadic(Parser(Combinators(For(The(Real(
World
Daan$Leijen
• h#p://research.microso0.com/en2us/um/people/daan/
download/papers/parsec2paper.pdf

28. Examples
• Rob%Rix%(%Madness%(%h0ps://github.com/robrix/Madness
• Parsec%