Update Madness to master

Cartfile

@@ -1,4 +1,4 @@
-github "robrix/Madness" "significant-indentation"
-github "robrix/Either" ~> 1.1
-github "robrix/Box" ~> 1.0.1
-github "robrix/Prelude" ~> 1.4
+github "robrix/Madness" "master"
+github "robrix/Either" ~> 1.2.2
+github "robrix/Box" ~> 1.2.2
+github "robrix/Prelude" ~> 1.5

Cartfile.private

@@ -1,3 +1,3 @@
 github "jspahrsummers/xcconfigs"
-github "Quick/Quick" ~> 0.2.2
-github "Quick/Nimble" ~> 0.2
+github "Quick/Quick" ~> 0.3.1
+github "Quick/Nimble" ~> 1.0.0

Cartfile.resolved

@@ -1,7 +1,7 @@
-github "robrix/Box" "1.0.1"
-github "robrix/Either" "1.1"
-github "robrix/Madness" "b5e2882e924b2377da83adcdb59592ba7fdab52a"
-github "Quick/Nimble" "v0.2.0"
-github "robrix/Prelude" "1.4"
-github "Quick/Quick" "v0.2.2"
-github "jspahrsummers/xcconfigs" "0.7.1"
+github "robrix/Box" "1.2.2"
+github "Quick/Nimble" "v1.0.0"
+github "robrix/Prelude" "1.5.0"
+github "Quick/Quick" "v0.3.1"
+github "jspahrsummers/xcconfigs" "0.8.1"
+github "robrix/Either" "1.2.2"
+github "robrix/Madness" "fa440dd21e7341f687f748afd98ccb12574e1bd0"

OGDL/Parser.swift

@@ -12,30 +12,27 @@ import Madness
 import Prelude
 
 /// Returns a parser which parses one character from the given set.
-internal prefix func % (characterSet: NSCharacterSet) -> Parser<String>.Function {
-	return { string in
-		let scalars = string.unicodeScalars
-
-		if let scalar = first(scalars) {
-			if characterSet.longCharacterIsMember(scalar.value) {
-				return (String(scalar), String(dropFirst(scalars)))
-			}
-		}
-
-		return nil
+internal prefix func % <C: CollectionType where C.Generator.Element == Character>(characterSet: NSCharacterSet) -> Parser<C, String>.Function {
+	return { collection, index in
+        if index != collection.endIndex {
+            if let scalar = first(String(collection[index]).unicodeScalars) where characterSet.longCharacterIsMember(scalar.value) {
+                return .right(String(scalar), index.successor())
+            }
+        }
+		return .left(.leaf("Character is not present in NSCharacterSet", index))
 	}
 }
 
 /// Removes the characters in the given string from the character set.
 internal func - (characterSet: NSCharacterSet, characters: String) -> NSCharacterSet {
-	let mutableSet = characterSet.mutableCopy() as NSMutableCharacterSet
+	let mutableSet = characterSet.mutableCopy() as! NSMutableCharacterSet
 	mutableSet.removeCharactersInString(characters)
 	return mutableSet
 }
 
 /// Removes characters in the latter set from the former.
 internal func - (characterSet: NSCharacterSet, subtrahend: NSCharacterSet) -> NSCharacterSet {
-	let mutableSet = characterSet.mutableCopy() as NSMutableCharacterSet
+	let mutableSet = characterSet.mutableCopy() as! NSMutableCharacterSet
 	mutableSet.formIntersectionWithCharacterSet(subtrahend.invertedSet)
 	return mutableSet
 }
@@ -44,8 +41,8 @@ internal func - (characterSet: NSCharacterSet, subtrahend: NSCharacterSet) -> NS
 postfix operator |? {}
 
 /// Matches zero or one occurrence of the given parser.
-internal postfix func |? <T>(parser: Parser<T>.Function) -> Parser<T?>.Function {
-	return (parser * (0..<2)) --> first
+internal postfix func |? <C: CollectionType, T where C.Generator.Element: Equatable>(parser: Parser<C, T>.Function) -> Parser<C, T?>.Function {
+	return first <^> (parser * (0..<2))
 }
 
 private let char_control = NSCharacterSet.controlCharacterSet()
@@ -57,43 +54,46 @@ private let char_break = NSCharacterSet.newlineCharacterSet()
 // TODO: Use this somewhere.
 private let char_end = char_control - NSCharacterSet.whitespaceAndNewlineCharacterSet()
 
-private let wordStart: Parser<String>.Function = %(char_word - "#'\"")
-private let wordChars: Parser<String>.Function = (%(char_word - "'\""))* --> { strings in join("", strings) }
-private let word: Parser<String>.Function = wordStart ++ wordChars --> (+)
-private let br: Parser<()>.Function = ignore(%char_break)
-private let eof: Parser<()>.Function = { $0 == "" ? ((), "") : nil }
-private let comment: Parser<()>.Function = ignore(%"#" ++ (%char_text)+ ++ (br | eof))
+private let wordStart: Parser<String, String>.Function = %(char_word - "#'\"")
+private let wordChars: Parser<String, String>.Function = { join("", $0) } <^> (%(char_word - "'\""))*
+private let word: Parser<String, String>.Function = (+) <^> wordStart ++ wordChars
+private let br: Parser<String, Ignore>.Function = ignore(%char_break)
+private let eof: Parser<String, Ignore>.Function = ignore("")//{ $0 == "" ? ((), "") : nil }
+
+private let br_eof = br | eof
+private let comment: Parser<String, Ignore>.Function = ignore(%"#" ++ (%char_text)+ ++ br_eof)
+
 // TODO: Escape sequences.
-private let singleQuotedChars: Parser<String>.Function = (%(char_text - "'"))* --> { strings in join("", strings) }
-private let singleQuoted: Parser<String>.Function = ignore(%"'") ++ singleQuotedChars ++ ignore(%"'")
-private let doubleQuotedChars: Parser<String>.Function = (%(char_text - "\""))* --> { strings in join("", strings) }
-private let doubleQuoted: Parser<String>.Function = ignore(%"\"") ++ doubleQuotedChars ++ ignore(%"\"")
-private let quoted: Parser<String>.Function = singleQuoted | doubleQuoted
-private let requiredSpace: Parser<()>.Function = ignore((comment | %char_space)+)
-private let optionalSpace: Parser<()>.Function = ignore((comment | %char_space)*)
-private let separator: Parser<()>.Function = ignore(optionalSpace ++ %"," ++ optionalSpace)
+private let singleQuotedChars: Parser<String, String>.Function = { join("", $0) } <^> (%(char_text - "'"))*
+private let singleQuoted: Parser<String, String>.Function = ignore(%"'") ++ singleQuotedChars ++ ignore(%"'")
+private let doubleQuotedChars: Parser<String, String>.Function = { join("", $0) } <^> (%(char_text - "\""))*
+private let doubleQuoted: Parser<String, String>.Function = ignore(%"\"") ++ doubleQuotedChars ++ ignore(%"\"")
+private let quoted: Parser<String, String>.Function = singleQuoted | doubleQuoted
+private let requiredSpace: Parser<String, Ignore>.Function = ignore((comment | %char_space)+)
+private let optionalSpace: Parser<String, Ignore>.Function = ignore((comment | %char_space)*)
+private let separator: Parser<String, Ignore>.Function = ignore(optionalSpace ++ %"," ++ optionalSpace)
 
-private let value: Parser<String>.Function = word | quoted
+private let value: Parser<String, String>.Function = word | quoted
 
 /// A function taking an Int and returning a parser which parses at least that many
 /// indentation characters.
-func indentation(n: Int) -> Parser<Int>.Function {
-	return (%char_space * (n..<Int.max)) --> { $0.count }
+func indentation(n: Int) -> Parser<String, Int>.Function {
+	return count <^> (%char_space * (n..<Int.max))
 }
 
 // MARK: Generic combinators
 // FIXME: move these into Madness.
 
 /// Delays the evaluation of a parser so that it can be used in a recursive grammar without deadlocking Swift at runtime.
-private func lazy<T>(parser: () -> Parser<T>.Function) -> Parser<T>.Function {
+private func lazy<C: CollectionType, T where C.Generator.Element: Equatable>(parser: () -> Parser<C, T>.Function) -> Parser<C, T>.Function {
 	return { parser()($0) }
 }
 
 /// Returns a parser which produces an array of parse trees produced by `parser` interleaved with ignored parses of `separator`.
 ///
 /// This is convenient for e.g. comma-separated lists.
-private func interleave<T, U>(separator: Parser<U>.Function, parser: Parser<T>.Function) -> Parser<[T]>.Function {
-	return (parser ++ (ignore(separator) ++ parser)*) --> { [$0] + $1 }
+private func interleave<C: CollectionType, T, U where C.Generator.Element: Equatable>(separator: Parser<C, U>.Function, parser: Parser<C, T>.Function) -> Parser<C, [T]>.Function {
+	return { [$0] + $1 } <^> (parser ++ (ignore(separator) ++ parser)*)
 }
 
 private func foldr<S: SequenceType, Result>(sequence: S, initial: Result, combine: (S.Generator.Element, Result) -> Result) -> Result {
@@ -105,12 +105,12 @@ private func foldr<G: GeneratorType, Result>(inout generator: G, initial: Result
 	return generator.next().map { combine($0, foldr(&generator, initial, combine)) } ?? initial
 }
 
-private func | <T, U> (left: Parser<T>.Function, right: String -> U) -> Parser<Either<T, U>>.Function {
-	return left | { (right($0), $0) }
+private func | <C: CollectionType, T, U where C.Generator.Element: Equatable>(left: Parser<C, T>.Function, right: () -> U) -> Parser<C, Either<T, U>>.Function {
+    return left | { .right(right(), $1 == $0.endIndex ? $1 : $1.successor()) }
 }
 
-private func | <T> (left: Parser<T>.Function, right: String -> T) -> Parser<T>.Function {
-	return left | { (right($0), $0) }
+private func | <C: CollectionType, T where C.Generator.Element: Equatable>(left: Parser<C, T>.Function, right: () -> T) -> Parser<C, T>.Function {
+    return left | { .right(right(), $1 == $0.endIndex ? $1 : $1.successor()) }
 }
 
 private func flatMap<T, U>(x: [T], f: T -> [U]) -> [U] {
@@ -119,45 +119,46 @@ private func flatMap<T, U>(x: [T], f: T -> [U]) -> [U] {
 
 // MARK: OGDL
 
-private let children: Parser<[Node]>.Function = lazy { group | (element --> { elem in [ elem ] }) }
+private let children: Parser<String, [Node]>.Function = lazy { group | ({ elem in [ elem ] } <^> element) }
 
-private let element = lazy { value ++ (optionalSpace ++ children)|? --> { value, children in Node(value: value, children: children ?? []) } }
+private let element = lazy { { Node(value: $0, children: $1 ?? []) } <^> value ++ (optionalSpace ++ children)|? }
 
 // TODO: See Carthage/ogdl-swift#3.
-private let block: Int -> Parser<()>.Function = { n in const(nil) }
+private let block: Int -> Parser<String, Ignore>.Function = { _ in ignore(any) }
 
 /// Parses a single descendent element.
 ///
 /// This is an element which may be an in-line descendent, and which may further have in-line descendents of its own.
-private let descendent = value --> { Node(value: $0) }
+private let descendent = { Node(value: $0) } <^> value
 
 /// Parses a sequence of hierarchically descending elements, e.g.:
 ///
 ///		x y z # => Node(x, [Node(y, Node(z))])
-public let descendents: Parser<Node>.Function = interleave(requiredSpace, descendent) --> {
-	foldr(dropLast($0), last($0)!) { $0.nodeByAppendingChildren([ $1 ]) }
-}
+public let descendents: Parser<String, Node>.Function =
+    { foldr(dropLast($0), last($0)!) { $0.nodeByAppendingChildren([ $1 ]) } }
+    <^> interleave(requiredSpace, descendent)
 
 /// Parses a chain of descendents, optionally ending in a group.
 ///
 ///		x y (u, v) # => Node(x, [ Node(y, [ Node(u), Node(v) ]) ])
-private let descendentChain: Parser<Node>.Function = (descendents ++ ((optionalSpace ++ group) | const([]))) --> uncurry(Node.nodeByAppendingChildren)
+private let descendentChain: Parser<String, Node>.Function =
+    uncurry(Node.nodeByAppendingChildren) <^> (descendents ++ ((optionalSpace ++ group) | const([])))
 
 /// Parses a sequence of adjacent sibling elements, e.g.:
 ///
 ///		x, y z, w (u, v) # => [ Node(x), Node(y, Node(z)), Node(w, [ Node(u), Node(v) ]) ]
-public let adjacent: Parser<[Node]>.Function = lazy { interleave(separator, descendentChain) }
+public let adjacent: Parser<String, [Node]>.Function = lazy { interleave(separator, descendentChain) }
 
 /// Parses a parenthesized sequence of sibling elements, e.g.:
 ///
 ///		(x, y z, w) # => [ Node(x), Node(y, Node(z)), Node(w) ]
 private let group = lazy { ignore(%"(") ++ optionalSpace ++ adjacent ++ optionalSpace ++ ignore(%")") }
 
-private let subgraph: Int -> Parser<[Node]>.Function = { n in
-	(descendents ++ lines(n + 1) --> { [ $0.nodeByAppendingChildren($1) ] }) | adjacent
+private let subgraph: Int -> Parser<String, [Node]>.Function = { n in
+	({ [ $0.nodeByAppendingChildren($1) ] } <^> descendents ++ lines(n + 1)) | adjacent
 }
 
-private let line: Int -> Parser<[Node]>.Function = fix { line in
+private let line: Int -> Parser<String, [Node]>.Function = fix { line in
 	{ n in
 		// TODO: block parsing: ignore(%char_space+ ++ block(n))|?) ++
 		// See Carthage/ogdl-swift#3.
@@ -167,14 +168,14 @@ private let line: Int -> Parser<[Node]>.Function = fix { line in
 	}
 }
 
-private let followingLine: Int -> Parser<[Node]>.Function = { n in (ignore(comment | br)+ ++ line(n)) }
-private let lines: Int -> Parser<[Node]>.Function = { n in
-	(line(n)|? ++ followingLine(n)*) --> { ($0 ?? []) + flatMap($1, id) }
+private let followingLine: Int -> Parser<String, [Node]>.Function = { n in (ignore(comment | br)+ ++ line(n)) }
+private let lines: Int -> Parser<String, [Node]>.Function = { n in
+    { ($0 ?? []) + flatMap($1, id) } <^> (line(n)|? ++ followingLine(n)*)
 }
 
 /// Parses a textual OGDL graph into a list of nodes (and their descendants).
 ///
 /// Example:
 ///
 ///   let nodes = parse(graph, "foo (bar, buzz baz)")
-public let graph: Parser<[Node]>.Function = ignore(comment | br)* ++ (lines(0) | adjacent) ++ ignore(comment | br)*
+public let graph: Parser<String, [Node]>.Function = ignore(comment | br)* ++ (lines(0) | adjacent) ++ ignore(comment | br)*

OGDLTests/ParserSpec.swift

@@ -15,34 +15,34 @@ import Quick
 class ParserSpec: QuickSpec {
 	override func spec() {
 		it("should parse the empty string") {
-			expect(parse(graph, "")).to(equal([]))
+			expect(parse(graph, "").right).to(equal([]))
 		}
 
 		it("should parse a line break") {
-			expect(parse(graph, "\n")).to(equal([]))
+			expect(parse(graph, "\n").right).to(equal([]))
 		}
 
 		it("should parse a series of line breaks") {
-			expect(parse(graph, "\n\n\n")).to(equal([]))
+			expect(parse(graph, "\n\n\n").right).to(equal([]))
 		}
 
 		it("should parse a single node with descendents") {
-			expect(parse(descendents, "foobar")).to(equal(Node(value: "foobar")))
+			expect(parse(descendents, "foobar").right).to(equal(Node(value: "foobar")))
 		}
 
 		it("should parse a single node with adjacent") {
-			expect(parse(adjacent, "foobar")).to(equal([ Node(value: "foobar") ]))
+			expect(parse(adjacent, "foobar").right).to(equal([ Node(value: "foobar") ]))
 		}
 
 		it("should parse a single node") {
 			let expectedGraph = [ Node(value: "foobar") ]
-			let parsedGraph = parse(graph, "foobar")
+			let parsedGraph = parse(graph, "foobar").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
 		it("should parse a single node ending with a newline") {
 			let expectedGraph = [ Node(value: "foobar") ]
-			let parsedGraph = parse(graph, "foobar\n")
+			let parsedGraph = parse(graph, "foobar\n").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
@@ -57,7 +57,7 @@ class ParserSpec: QuickSpec {
 				])
 			]
 
-			let parsedGraph = parse(graph, "foo bar fuzz buzz")
+			let parsedGraph = parse(graph, "foo bar fuzz buzz").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
@@ -70,7 +70,7 @@ class ParserSpec: QuickSpec {
 				])
 			]
 
-			let parsedGraph = parse(graph, "foo \"bar\" \"fuzz buzz\"")
+			let parsedGraph = parse(graph, "foo \"bar\" \"fuzz buzz\"").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
@@ -86,7 +86,7 @@ class ParserSpec: QuickSpec {
 				])
 			]
 
-			let parsedGraph = parse(graph, "foo bar, fuzz buzz")
+			let parsedGraph = parse(graph, "foo bar, fuzz buzz").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
@@ -99,7 +99,7 @@ class ParserSpec: QuickSpec {
 				])
 			]
 
-			let parsedGraph = parse(graph, "foo (bar, quux)")
+			let parsedGraph = parse(graph, "foo (bar, quux)").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
@@ -112,12 +112,12 @@ class ParserSpec: QuickSpec {
 				])
 			]
 
-			let parsedGraph = parse(graph, "foo ( bar.o 1.2, quux.o 2.1 )")
+			let parsedGraph = parse(graph, "foo ( bar.o 1.2, quux.o 2.1 )").right
 			expect(parsedGraph).to(equal(expectedGraph))
 		}
 
 		it("should parse comments") {
-			let parsedGraph = parse(graph, "#foo")
+			let parsedGraph = parse(graph, "#foo").right
 			expect(parsedGraph).to(equal([]))
 		}
 
@@ -142,10 +142,10 @@ class ParserSpec: QuickSpec {
 			for i in 1...5 {
 				let URL = NSBundle(forClass: self.dynamicType).URLForResource("Example2-\(i)", withExtension: "ogdl", subdirectory: "Samples")!
 
-				let sample = NSString(contentsOfURL: URL, encoding: NSUTF8StringEncoding, error: nil)
+				let sample = NSString(contentsOfURL: URL, encoding: NSUTF8StringEncoding, error: nil) as? String
 				expect(sample).notTo(beNil())
 
-				let parsedGraph = parse(graph, sample ?? "")
+				let parsedGraph = parse(graph, sample ?? "").right
 				if let parsedGraph = parsedGraph {
 					println("graph \(i):\n\(parsedGraph)\n")
 				}