         return repeatingParser
     }
 
-    return repeatingParser || success(empty)
+    return repeatingParser || success(nil)
 }

///
public func chainLeft<T, Element>(_ parser: @autoclosure @escaping () -> Parser<T, Element>,
                                  separator: @autoclosure @escaping () -> Parser<(T, T) -> T, Element>,
                                  empty: T,
                                  min: Int = 0,
                                  max: Int? = nil)
    -> Parser<T, Element>
{
    typealias Op = (T, T) -> T

    let lazyParser = Lazy(parser)
    let lazySeparator = Lazy(separator)

    let repeatingParser =
        lazyParser.value.seq(lazySeparator.value.seq(lazyParser.value).rep(min: min, max: max))
            ^^ { (firstAndRest: (T, [(Op, T)])) -> T in
                let (first, rest) = firstAndRest

    ///   - max: The maximum number of times this parser is to be applied.
    ///
    public func chainLeft(_ separator: @autoclosure @escaping () -> Parser<(T, T) -> T, Element>,
                          min: Int = 0, max: Int? = nil)
        -> Parser<T?, Element>
    {
        return SwiftParserCombinators.chainLeft(self,
                                                separator: separator,
                                                min: min,
                                                max: max)
    }
