Add a monadic bind operator

Sources/Durian/AnyCombinator.swift

@@ -3,12 +3,12 @@ public struct AnyCombinator<Context, Element>: Combinator {
 
  private var _parse: (inout Context) throws -> Element?
 
- /// Creates a new combinator that forwards operations to `base`.
+ /// Creates a type-erased combinator that forwards operations to `base`.
  public init<C: Combinator>(_ base: C) where C.Context == Context, C.Element == Element {
  self._parse = base.parse(_:)
  }
 
- /// Creates a new combinator that forwards operations to `parse`.
+ /// Creates a type-erased combinator that forwards operations to `parse`.
  public init(parse: @escaping (inout Context) throws -> Element?) {
  self._parse = parse
  }

Sources/Durian/Bind.swift

@@ -0,0 +1,31 @@
+/// A combinator that applies a combinator and then, if successful, passes its result to a
+/// function returning the next combinator to apply.
+public struct Bind<Base: Combinator, Next: Combinator>: Combinator
+where Base.Context == Next.Context
+{
+
+ public typealias Context = Base.Context
+
+ public typealias Element = Next.Element
+
+ /// The base combinator.
+ public let base: Base
+
+ /// A function that accepts the result of `base` and returns a new combinator.
+ public let makeNext: (Base.Element) throws -> Next
+
+ /// Creates a combinator that applies `base` and then the combinator returned by `makeNext`.
+ public init(_ base: Base, and makeNext: @escaping (Base.Element) throws -> Next) {
+ self.base = base
+ self.makeNext = makeNext
+ }
+
+ public func parse(_ context: inout Context) throws -> Next.Element? {
+ if let a = try base.parse(&context) {
+ return try makeNext(a).parse(&context)
+ } else {
+ return nil
+ }
+ }
+
+}

Sources/Durian/Combinator.swift

@@ -34,6 +34,13 @@ extension Combinator {
  Combine(self, and: other, else: makeHardFailure)
  }
 
+ /// Creates a combinator that applies `self` and then the result of `makeNext`.
+ public func bind<Next: Combinator>(
+ _ makeNext: @escaping (Element) throws -> Next
+ ) -> Bind<Self, Next> {
+ Bind(self, and: makeNext)
+ }
+
  /// Creates a combinator that applies `self`, or backtracks and applies `other` when `self`
  /// return a soft failure.
  public func or<Other: Combinator>(_ other: Other) -> Choose<Self, Other> {
@@ -48,7 +55,7 @@ extension Combinator {
  TryCatch(trying: self, orCatchingAndApplying: other)
  }
 
- /// Creates a combinators that transforms the result of `self`.
+ /// Creates a combinator that transforms the result of `self`.
  public func map<T>(
  _ transform: @escaping (inout Context, Element) throws -> T
  ) -> Transform<Self, T> {

Tests/DurianTests/DurianTests.swift

@@ -14,6 +14,16 @@ final class DurianTests: XCTestCase {
  XCTAssertEqual(context, "bc")
  }
 
+ func testBind() throws {
+ let a = PopFirst<Substring>(if: { $0 == "a" })
+ let aAndA = a.bind({ (ch) in PopFirst(if: { $0 == ch }) })
+
+ let input = "aab"
+ var context = input.suffix(from: input.startIndex)
+ XCTAssertEqual(try aAndA.parse(&context), "a")
+ XCTAssertEqual(context, "b")
+ }
+
  func testChooseFirst() {
  let a = PopFirst<Substring>(if: { $0 == "a" })
  let b = PopFirst<Substring>(if: { $0 == "b" })