         
         let stringLiteral = between(character("\""), character("\""), parse: until(character("\""))).stringify().withError("string literal")
         
-        let symbol = within("()+-*/").withError("symbol")
+        let symbol = within("()+-*/[],").withError("symbol")
         
         let comment = recurive { parser in
             between(string("/*"), string("*/"), parse: appending(

        ), delimiter: many(coalesce(whitespace, comment))))
        
        do {
            let result = try tokens.parse("((hello (+5 * -3  /* this is a /* nested */ comment */ ) 5.0   \"world\" -43.56  )4  whoa)")
            XCTAssertEqual(15, result.count)
            
            let sExpression = recurive { (parser: Parser<SchemeToken, Expression>) in
                coalesce(
                    between(token(SchemeToken.Symbol("(")), token(SchemeToken.Symbol(")")), parse: many(parser)).map(Expression.SExpression),
                    unless(token(SchemeToken.Symbol(")"))).map(Expression.Token)
                )
            }
            


enum Expression: CustomStringConvertible {
    indirect case SExpression([Expression])
    case ArrayLiteral([SchemeToken])
    case Token(SchemeToken)
    
    var description: String {
        switch self {
        case .SExpression(let expressions): return "Expression@" + expressions.description
        case .Token(let token): return token.description
        case .ArrayLiteral(let arr): return "Array@" + arr.description
        }
    }
}
