                         rest = @require parseInner,
                             args:
                                 amtLeft: args.amtLeft - 1
-                cons first, rest
+                    cons first, rest
         makeParser ->
-            findings = []
             if other?.start
                 @require other.start
             findings = @require parseInner

last = (xs) -> xs[xs.length - 1]
empty = (l) -> l.length is 0
concat = (xs, ys) -> xs.concat(ys)
makeParsingInstance = do ->
    isParser = (x) -> util.typeOf(x) is "function" and x.isParser
    makeSureParser = (x) -> if isParser(x) then x else makeParser(x)
    parserUser = (which) -> # This is the abstraction for @optional and @require
        (a, b, c) ->
            # Handle all arrangements of arguments:
            #  (The arrangements are (lookFor, found, notFound); (lookFor, {found, notFound, dontAdvance, args}); ({lookFor, found, notFound, dontAdvance, args}))
            if util.typeOf(a) is "null" or util.typeOf(a) is "undefined" or util.typeOf(a) is "number"
                throw new Error "Invalid argument to @" + which + "."
            if util.typeOf(a) is "object"
                prsr = makeSureParser a.lookFor
                other = a

        "getArray":   getArray
        "getObject":  getObject
    }
Object.freeze makeParser

### TODO: Things to THINK ABOUT for the future:
 -Allowing some easier way of creating parsers like ones from makeParser
