edn_turbo 0.3.1 → 0.3.2

data/ext/edn_turbo/edn_parser.cc

@@ -16,7 +16,7 @@
 //
 
 
-#line 59 "edn_parser.rl"
+#line 54 "edn_parser.rl"
 
 
 // ============================================================
@@ -32,23 +32,24 @@ static const int EDN_value_error = 0;
 static const int EDN_value_en_main = 1;
 
 
-#line 175 "edn_parser.rl"
+#line 170 "edn_parser.rl"
 
 
 
 const char *edn::Parser::parse_value(const char *p, const char *pe, VALUE& v)
 {
+    //    std::cerr << __FUNCTION__ << "() p: \"" << p << "\"" << std::endl;
     int cs;
 
 
-#line 45 "edn_parser.cc"
+#line 46 "edn_parser.cc"
 	{
 	cs = EDN_value_start;
 	}
 
-#line 183 "edn_parser.rl"
+#line 179 "edn_parser.rl"
 
-#line 52 "edn_parser.cc"
+#line 53 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -68,7 +69,7 @@ case 1:
 	}
 	if ( (*p) < 48 ) {
 		if ( (*p) < 42 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+			if ( 33 <= (*p) && (*p) <= 39 )
 				goto tr0;
 		} else if ( (*p) > 43 ) {
 			if ( 45 <= (*p) && (*p) <= 47 )
@@ -91,7 +92,7 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 103 "edn_parser.rl"
+#line 98 "edn_parser.rl"
 	{
         // stand-alone operators *, +, -, etc.
         const char *np = parse_operator(p, pe, v);
@@ -99,7 +100,7 @@ tr0:
     }
 	goto st2;
 tr2:
-#line 71 "edn_parser.rl"
+#line 66 "edn_parser.rl"
 	{
         // string types within double-quotes
         const char *np = parse_string(p, pe, v);
@@ -107,7 +108,7 @@ tr2:
     }
 	goto st2;
 tr3:
-#line 155 "edn_parser.rl"
+#line 150 "edn_parser.rl"
 	{
         // handles tokens w/ leading # ("#_", "#{", and tagged elems)
         const char *np = parse_dispatch(p + 1, pe, v);
@@ -115,7 +116,7 @@ tr3:
     }
 	goto st2;
 tr4:
-#line 137 "edn_parser.rl"
+#line 132 "edn_parser.rl"
 	{
         // (
         const char *np = parse_list(p, pe, v);
@@ -123,7 +124,7 @@ tr4:
     }
 	goto st2;
 tr5:
-#line 83 "edn_parser.rl"
+#line 78 "edn_parser.rl"
 	{
         // tokens w/ leading digits: non-negative integers & decimals.
         // try to parse a decimal first
@@ -139,13 +140,13 @@ tr5:
             {p++; cs = 2; goto _out;}
         }
         else {
-            error(__FUNCTION__, *p);
+            error(__FUNCTION__, "number format error", *p);
             {p = (( pe))-1;}
         }
     }
 	goto st2;
 tr6:
-#line 77 "edn_parser.rl"
+#line 72 "edn_parser.rl"
 	{
         // tokens with a leading ':'
         const char *np = parse_keyword(p, pe, v);
@@ -153,25 +154,25 @@ tr6:
     }
 	goto st2;
 tr7:
-#line 115 "edn_parser.rl"
+#line 110 "edn_parser.rl"
 	{
         // user identifiers and reserved keywords (true, false, nil)
         VALUE sym = Qnil;
         const char *np = parse_symbol(p, pe, sym);
-        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
+        if (np == NULL) { {p = (( pe))-1;} } else {
             // parse_symbol will make 'sym' a ruby string
             if      (std::strcmp(RSTRING_PTR(sym), "true") == 0)  { v = Qtrue; }
             else if (std::strcmp(RSTRING_PTR(sym), "false") == 0) { v = Qfalse; }
             else if (std::strcmp(RSTRING_PTR(sym), "nil") == 0)   { v = Qnil; }
             else {
-                v = Parser::make_edn_symbol(sym);
+                v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
             }
             {p = (( np))-1;}
         }
     }
 	goto st2;
 tr8:
-#line 131 "edn_parser.rl"
+#line 126 "edn_parser.rl"
 	{
         // [
         const char *np = parse_vector(p, pe, v);
@@ -179,7 +180,7 @@ tr8:
     }
 	goto st2;
 tr9:
-#line 109 "edn_parser.rl"
+#line 104 "edn_parser.rl"
 	{
         // tokens w/ leading \ (escaped characters \newline, \c, etc.)
         const char *np = parse_esc_char(p, pe, v);
@@ -187,7 +188,7 @@ tr9:
     }
 	goto st2;
 tr10:
-#line 149 "edn_parser.rl"
+#line 144 "edn_parser.rl"
 	{
         // ^
         const char *np = parse_meta(p, pe);
@@ -195,7 +196,7 @@ tr10:
     }
 	goto st2;
 tr11:
-#line 143 "edn_parser.rl"
+#line 138 "edn_parser.rl"
 	{
         // {
         const char *np = parse_map(p, pe, v);
@@ -206,9 +207,9 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
-#line 212 "edn_parser.cc"
+#line 213 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -217,13 +218,13 @@ case 2:
 	_out: {}
 	}
 
-#line 184 "edn_parser.rl"
+#line 180 "edn_parser.rl"
 
     if (cs >= EDN_value_first_final) {
         return p;
     }
     else if (cs == EDN_value_error) {
-        error(__FUNCTION__, *p);
+        error(__FUNCTION__, "token error", *p);
         return pe;
     }
     else if (cs == EDN_value_en_main) {} // silence ragel warning
@@ -239,7 +240,7 @@ case 2:
 // ascii range is found.
 //
 
-#line 243 "edn_parser.cc"
+#line 244 "edn_parser.cc"
 static const int EDN_string_start = 1;
 static const int EDN_string_first_final = 8;
 static const int EDN_string_error = 0;
@@ -247,7 +248,7 @@ static const int EDN_string_error = 0;
 static const int EDN_string_en_main = 1;
 
 
-#line 229 "edn_parser.rl"
+#line 225 "edn_parser.rl"
 
 
 
@@ -258,15 +259,15 @@ const char* edn::Parser::parse_string(const char *p, const char *pe, VALUE& v)
     bool encode = false;
 
 
-#line 262 "edn_parser.cc"
+#line 263 "edn_parser.cc"
 	{
 	cs = EDN_string_start;
 	}
 
-#line 239 "edn_parser.rl"
+#line 235 "edn_parser.rl"
     const char* p_save = p;
 
-#line 270 "edn_parser.cc"
+#line 271 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -276,21 +277,11 @@ case 1:
 	if ( (*p) == 34 )
 		goto st2;
 	goto st0;
-tr3:
-#line 51 "edn_parser.rl"
-	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
-	goto st0;
-#line 289 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr2:
-#line 218 "edn_parser.rl"
+#line 214 "edn_parser.rl"
 	{
         encode = true;
     }
@@ -299,19 +290,16 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 303 "edn_parser.cc"
+#line 294 "edn_parser.cc"
 	switch( (*p) ) {
-		case 34: goto tr4;
-		case 92: goto tr5;
+		case 34: goto tr3;
+		case 92: goto tr4;
 	}
-	if ( (*p) > -11 ) {
-		if ( 0 <= (*p) && (*p) <= 31 )
-			goto tr3;
-	} else if ( (*p) >= -62 )
+	if ( -62 <= (*p) && (*p) <= -11 )
 		goto tr2;
 	goto st2;
-tr4:
-#line 210 "edn_parser.rl"
+tr3:
+#line 206 "edn_parser.rl"
 	{
         if (Parser::parse_byte_stream(p_save + 1, p, v, encode)) {
             {p = (( p + 1))-1;}
@@ -319,17 +307,17 @@ tr4:
             p--; {p++; cs = 8; goto _out;}
         }
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 8; goto _out;} }
 	goto st8;
 st8:
 	if ( ++p == pe )
 		goto _test_eof8;
 case 8:
-#line 330 "edn_parser.cc"
+#line 318 "edn_parser.cc"
 	goto st0;
-tr5:
-#line 218 "edn_parser.rl"
+tr4:
+#line 214 "edn_parser.rl"
 	{
         encode = true;
     }
@@ -338,7 +326,7 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 342 "edn_parser.cc"
+#line 330 "edn_parser.cc"
 	switch( (*p) ) {
 		case 34: goto tr2;
 		case 47: goto tr2;
@@ -348,13 +336,11 @@ case 3:
 		case 110: goto tr2;
 		case 114: goto tr2;
 		case 116: goto tr2;
-		case 117: goto tr6;
+		case 117: goto tr5;
 	}
-	if ( 0 <= (*p) && (*p) <= 31 )
-		goto st0;
 	goto st2;
-tr6:
-#line 218 "edn_parser.rl"
+tr5:
+#line 214 "edn_parser.rl"
 	{
         encode = true;
     }
@@ -363,18 +349,18 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 367 "edn_parser.cc"
+#line 353 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr7;
+			goto tr6;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto tr7;
+			goto tr6;
 	} else
-		goto tr7;
+		goto tr6;
 	goto st0;
-tr7:
-#line 218 "edn_parser.rl"
+tr6:
+#line 214 "edn_parser.rl"
 	{
         encode = true;
     }
@@ -383,18 +369,18 @@ st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 387 "edn_parser.cc"
+#line 373 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr8;
+			goto tr7;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto tr8;
+			goto tr7;
 	} else
-		goto tr8;
+		goto tr7;
 	goto st0;
-tr8:
-#line 218 "edn_parser.rl"
+tr7:
+#line 214 "edn_parser.rl"
 	{
         encode = true;
     }
@@ -403,18 +389,18 @@ st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 407 "edn_parser.cc"
+#line 393 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr9;
+			goto tr8;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto tr9;
+			goto tr8;
 	} else
-		goto tr9;
+		goto tr8;
 	goto st0;
-tr9:
-#line 218 "edn_parser.rl"
+tr8:
+#line 214 "edn_parser.rl"
 	{
         encode = true;
     }
@@ -423,7 +409,7 @@ st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 427 "edn_parser.cc"
+#line 413 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr2;
@@ -447,7 +433,7 @@ case 7:
 	{
 	switch ( cs ) {
 	case 2:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -455,14 +441,14 @@ case 7:
             p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 459 "edn_parser.cc"
+#line 445 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 241 "edn_parser.rl"
+#line 237 "edn_parser.rl"
 
     if (cs >= EDN_string_first_final) {
         return p + 1;
@@ -480,7 +466,7 @@ case 7:
 // keyword parsing
 //
 
-#line 484 "edn_parser.cc"
+#line 470 "edn_parser.cc"
 static const int EDN_keyword_start = 1;
 static const int EDN_keyword_first_final = 3;
 static const int EDN_keyword_error = 0;
@@ -488,7 +474,7 @@ static const int EDN_keyword_error = 0;
 static const int EDN_keyword_en_main = 1;
 
 
-#line 270 "edn_parser.rl"
+#line 267 "edn_parser.rl"
 
 
 
@@ -497,15 +483,15 @@ const char* edn::Parser::parse_keyword(const char *p, const char *pe, VALUE& v)
     int cs;
 
 
-#line 501 "edn_parser.cc"
+#line 487 "edn_parser.cc"
 	{
 	cs = EDN_keyword_start;
 	}
 
-#line 278 "edn_parser.rl"
+#line 275 "edn_parser.rl"
     const char* p_save = p;
 
-#line 509 "edn_parser.cc"
+#line 495 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -522,13 +508,24 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-	if ( (*p) == 35 )
-		goto st3;
-	if ( (*p) < 65 ) {
-		if ( 46 <= (*p) && (*p) <= 47 )
+	switch( (*p) ) {
+		case 33: goto st3;
+		case 95: goto st3;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st3;
+		} else if ( (*p) >= 35 )
 			goto st3;
-	} else if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
+	} else if ( (*p) > 46 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st3;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st3;
+		} else
 			goto st3;
 	} else
 		goto st3;
@@ -539,6 +536,7 @@ st3:
 case 3:
 	switch( (*p) ) {
 		case 33: goto st3;
+		case 47: goto st5;
 		case 95: goto st3;
 	}
 	if ( (*p) < 45 ) {
@@ -560,25 +558,53 @@ case 3:
 		goto st3;
 	goto tr3;
 tr3:
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 571 "edn_parser.cc"
+#line 569 "edn_parser.cc"
 	goto st0;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+	switch( (*p) ) {
+		case 33: goto st5;
+		case 47: goto st0;
+		case 95: goto st5;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st5;
+		} else if ( (*p) >= 35 )
+			goto st5;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st5;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st5;
+		} else
+			goto st5;
+	} else
+		goto st5;
+	goto tr3;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
 	_test_eof3: cs = 3; goto _test_eof;
 	_test_eof4: cs = 4; goto _test_eof;
+	_test_eof5: cs = 5; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 280 "edn_parser.rl"
+#line 277 "edn_parser.rl"
 
     if (cs >= EDN_keyword_first_final) {
         std::string buf;
@@ -589,7 +615,7 @@ case 4:
         return p;
     }
     else if (cs == EDN_keyword_error) {
-        error(__FUNCTION__, *p);
+        error(__FUNCTION__, "invalid keyword", *p);
         return pe;
     }
     else if (cs == EDN_keyword_en_main) {} // silence ragel warning
@@ -602,14 +628,14 @@ case 4:
 // decimal parsing machine
 //
 
-#line 606 "edn_parser.cc"
+#line 632 "edn_parser.cc"
 static const int EDN_decimal_start = 1;
 static const int EDN_decimal_first_final = 9;
 
 static const int EDN_decimal_en_main = 1;
 
 
-#line 313 "edn_parser.rl"
+#line 310 "edn_parser.rl"
 
 
 
@@ -618,15 +644,15 @@ const char* edn::Parser::parse_decimal(const char *p, const char *pe, VALUE& v)
     int cs;
 
 
-#line 622 "edn_parser.cc"
+#line 648 "edn_parser.cc"
 	{
 	cs = EDN_decimal_start;
 	}
 
-#line 321 "edn_parser.rl"
+#line 318 "edn_parser.rl"
     const char* p_save = p;
 
-#line 630 "edn_parser.cc"
+#line 656 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -680,14 +706,14 @@ case 9:
 		goto st0;
 	goto tr10;
 tr10:
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 10; goto _out;} }
 	goto st10;
 st10:
 	if ( ++p == pe )
 		goto _test_eof10;
 case 10:
-#line 691 "edn_parser.cc"
+#line 717 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -803,7 +829,7 @@ case 8:
 	_out: {}
 	}
 
-#line 323 "edn_parser.rl"
+#line 320 "edn_parser.rl"
 
     if (cs >= EDN_decimal_first_final) {
         v = Parser::float_to_ruby(p_save, p - p_save);
@@ -815,17 +841,17 @@ case 8:
 
 
 // ============================================================
-// integer parsing machine
+// integer parsing machine - M suffix will return a BigNum
 //
 
-#line 822 "edn_parser.cc"
+#line 848 "edn_parser.cc"
 static const int EDN_integer_start = 1;
 static const int EDN_integer_first_final = 3;
 
 static const int EDN_integer_en_main = 1;
 
 
-#line 346 "edn_parser.rl"
+#line 343 "edn_parser.rl"
 
 
 const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
@@ -833,15 +859,15 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
     int cs;
 
 
-#line 837 "edn_parser.cc"
+#line 863 "edn_parser.cc"
 	{
 	cs = EDN_integer_start;
 	}
 
-#line 353 "edn_parser.rl"
+#line 350 "edn_parser.rl"
     const char* p_save = p;
 
-#line 845 "edn_parser.cc"
+#line 871 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -883,14 +909,14 @@ case 3:
 		goto st0;
 	goto tr4;
 tr4:
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 894 "edn_parser.cc"
+#line 920 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -931,7 +957,7 @@ case 6:
 	_out: {}
 	}
 
-#line 355 "edn_parser.rl"
+#line 352 "edn_parser.rl"
 
     if (cs >= EDN_integer_first_final) {
         v = Parser::integer_to_ruby(p_save, p - p_save);
@@ -951,7 +977,7 @@ case 6:
 // 3. stand-alone operators: +, -, /, *, etc.
 //
 
-#line 955 "edn_parser.cc"
+#line 981 "edn_parser.cc"
 static const int EDN_operator_start = 1;
 static const int EDN_operator_first_final = 3;
 static const int EDN_operator_error = 0;
@@ -959,7 +985,7 @@ static const int EDN_operator_error = 0;
 static const int EDN_operator_en_main = 1;
 
 
-#line 425 "edn_parser.rl"
+#line 426 "edn_parser.rl"
 
 
 
@@ -968,15 +994,15 @@ const char* edn::Parser::parse_operator(const char *p, const char *pe, VALUE& v)
     int cs;
 
 
-#line 972 "edn_parser.cc"
+#line 998 "edn_parser.cc"
 	{
 	cs = EDN_operator_start;
 	}
 
-#line 433 "edn_parser.rl"
+#line 434 "edn_parser.rl"
     const char* p_save = p;
 
-#line 980 "edn_parser.cc"
+#line 1006 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -986,13 +1012,13 @@ case 1:
 	switch( (*p) ) {
 		case 33: goto st3;
 		case 42: goto st3;
-		case 43: goto st7;
-		case 45: goto st7;
-		case 46: goto st9;
+		case 43: goto st8;
+		case 45: goto st8;
+		case 46: goto st11;
 		case 47: goto st3;
 		case 95: goto st3;
 	}
-	if ( (*p) > 38 ) {
+	if ( (*p) > 39 ) {
 		if ( 60 <= (*p) && (*p) <= 63 )
 			goto st3;
 	} else if ( (*p) >= 36 )
@@ -1008,139 +1034,148 @@ case 3:
 	switch( (*p) ) {
 		case 10: goto tr8;
 		case 32: goto tr7;
-		case 33: goto st0;
+		case 33: goto tr9;
 		case 44: goto tr7;
-		case 59: goto tr9;
-		case 95: goto st0;
+		case 59: goto tr10;
+		case 95: goto tr9;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 36 <= (*p) && (*p) <= 38 )
-				goto st0;
+			if ( 35 <= (*p) && (*p) <= 39 )
+				goto tr9;
 		} else if ( (*p) >= 9 )
 			goto tr7;
-	} else if ( (*p) > 57 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st0;
-		} else if ( (*p) > 90 ) {
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st0;
-		} else
-			goto st0;
+				goto tr9;
+		} else if ( (*p) >= 65 )
+			goto tr9;
 	} else
-		goto st0;
+		goto tr9;
 	goto tr6;
 tr6:
-#line 412 "edn_parser.rl"
+#line 410 "edn_parser.rl"
 	{
         // stand-alone operators (-, +, /, ... etc)
         char op[2] = { *p_save, 0 };
         VALUE sym = rb_str_new2(op);
-        v = Parser::make_edn_symbol(sym);
+        v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
-tr10:
-#line 58 "edn_parser.rl"
+tr11:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 4; goto _out;} }
+	goto st4;
+tr17:
+#line 376 "edn_parser.rl"
+	{
+        // parse a symbol including the leading operator (-, +, .)
+        VALUE sym = Qnil;
+        const char *np = parse_symbol(p_save, pe, sym);
+        if (np == NULL) { {p = (( pe))-1;} } else {
+            if (sym != Qnil)
+                v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
+            {p = (( np))-1;}
+        }
+    }
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1054 "edn_parser.cc"
+#line 1092 "edn_parser.cc"
 	goto st0;
 tr5:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
 	goto st5;
 tr7:
-#line 412 "edn_parser.rl"
+#line 410 "edn_parser.rl"
 	{
         // stand-alone operators (-, +, /, ... etc)
         char op[2] = { *p_save, 0 };
         VALUE sym = rb_str_new2(op);
-        v = Parser::make_edn_symbol(sym);
+        v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 tr8:
-#line 412 "edn_parser.rl"
+#line 410 "edn_parser.rl"
 	{
         // stand-alone operators (-, +, /, ... etc)
         char op[2] = { *p_save, 0 };
         VALUE sym = rb_str_new2(op);
-        v = Parser::make_edn_symbol(sym);
+        v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
     }
 #line 20 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
-tr11:
-#line 58 "edn_parser.rl"
+tr12:
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
-tr12:
+tr13:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 1098 "edn_parser.cc"
+#line 1136 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr12;
-		case 32: goto tr11;
+		case 10: goto tr13;
+		case 32: goto tr12;
 		case 33: goto st0;
-		case 44: goto tr11;
-		case 59: goto tr13;
+		case 44: goto tr12;
+		case 59: goto tr14;
 		case 95: goto st0;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 36 <= (*p) && (*p) <= 38 )
+			if ( 35 <= (*p) && (*p) <= 39 )
 				goto st0;
 		} else if ( (*p) >= 9 )
-			goto tr11;
-	} else if ( (*p) > 57 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st0;
-		} else if ( (*p) > 90 ) {
+			goto tr12;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
 				goto st0;
-		} else
+		} else if ( (*p) >= 65 )
 			goto st0;
 	} else
 		goto st0;
-	goto tr10;
-tr9:
-#line 412 "edn_parser.rl"
+	goto tr11;
+tr10:
+#line 410 "edn_parser.rl"
 	{
         // stand-alone operators (-, +, /, ... etc)
         char op[2] = { *p_save, 0 };
         VALUE sym = rb_str_new2(op);
-        v = Parser::make_edn_symbol(sym);
+        v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
-tr13:
-#line 58 "edn_parser.rl"
+tr14:
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 1144 "edn_parser.cc"
+#line 1179 "edn_parser.cc"
 	if ( (*p) == 10 )
 		goto tr5;
 	goto st2;
@@ -1151,41 +1186,21 @@ case 2:
 	if ( (*p) == 10 )
 		goto tr5;
 	goto st2;
-st7:
-	if ( ++p == pe )
-		goto _test_eof7;
-case 7:
-	switch( (*p) ) {
-		case 10: goto tr8;
-		case 32: goto tr7;
-		case 33: goto st0;
-		case 44: goto tr7;
-		case 59: goto tr9;
-		case 95: goto st0;
-	}
-	if ( (*p) < 48 ) {
-		if ( (*p) < 36 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto tr7;
-		} else if ( (*p) > 38 ) {
-			if ( 42 <= (*p) && (*p) <= 47 )
-				goto st0;
-		} else
-			goto st0;
-	} else if ( (*p) > 57 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st0;
-		} else if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto tr15;
-		} else
-			goto tr15;
-	} else
-		goto tr14;
-	goto tr6;
-tr14:
-#line 389 "edn_parser.rl"
+tr9:
+#line 376 "edn_parser.rl"
+	{
+        // parse a symbol including the leading operator (-, +, .)
+        VALUE sym = Qnil;
+        const char *np = parse_symbol(p_save, pe, sym);
+        if (np == NULL) { {p = (( pe))-1;} } else {
+            if (sym != Qnil)
+                v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
+            {p = (( np))-1;}
+        }
+    }
+	goto st7;
+tr16:
+#line 387 "edn_parser.rl"
 	{
         // parse a number with the leading symbol - this is slightly
         // different than the one within EDN_value since it includes
@@ -1201,42 +1216,30 @@ tr14:
         if (np) {
             {p = (( np))-1;}
             p--;
-            {p++; cs = 8; goto _out;}
+            {p++; cs = 7; goto _out;}
         }
         else {
-            error(__FUNCTION__, *p);
+            error(__FUNCTION__, "number format error", *p);
             {p = (( pe))-1;}
         }
     }
-	goto st8;
-tr15:
-#line 379 "edn_parser.rl"
-	{
-        // parse a symbol including the leading operator (-, +, .)
-        VALUE sym = Qnil;
-        const char *np = parse_symbol(p_save, pe, sym);
-        if (np == NULL) { p--; {p++; cs = 8; goto _out;} } else {
-            v = Parser::make_edn_symbol(sym);
-            {p = (( np))-1;}
-        }
-    }
-	goto st8;
-st8:
+	goto st7;
+st7:
 	if ( ++p == pe )
-		goto _test_eof8;
-case 8:
-#line 1229 "edn_parser.cc"
+		goto _test_eof7;
+case 7:
+#line 1232 "edn_parser.cc"
 	switch( (*p) ) {
 		case 33: goto st0;
 		case 95: goto st0;
 	}
 	if ( (*p) < 45 ) {
-		if ( (*p) > 38 ) {
+		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
 				goto st0;
-		} else if ( (*p) >= 36 )
+		} else if ( (*p) >= 35 )
 			goto st0;
-	} else if ( (*p) > 57 ) {
+	} else if ( (*p) > 58 ) {
 		if ( (*p) < 65 ) {
 			if ( 60 <= (*p) && (*p) <= 63 )
 				goto st0;
@@ -1247,76 +1250,193 @@ case 8:
 			goto st0;
 	} else
 		goto st0;
-	goto tr10;
-st9:
+	goto tr11;
+st8:
 	if ( ++p == pe )
-		goto _test_eof9;
-case 9:
+		goto _test_eof8;
+case 8:
 	switch( (*p) ) {
 		case 10: goto tr8;
 		case 32: goto tr7;
-		case 33: goto st0;
+		case 33: goto st9;
 		case 44: goto tr7;
-		case 59: goto tr9;
-		case 95: goto st0;
+		case 59: goto tr10;
+		case 95: goto st9;
 	}
-	if ( (*p) < 42 ) {
-		if ( (*p) > 13 ) {
-			if ( 36 <= (*p) && (*p) <= 38 )
-				goto st0;
-		} else if ( (*p) >= 9 )
-			goto tr7;
+	if ( (*p) < 48 ) {
+		if ( (*p) < 35 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto tr7;
+		} else if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 47 )
+				goto st9;
+		} else
+			goto st9;
 	} else if ( (*p) > 57 ) {
 		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st0;
+			if ( 58 <= (*p) && (*p) <= 63 )
+				goto st9;
 		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto tr15;
+				goto st9;
 		} else
-			goto tr15;
+			goto st9;
 	} else
-		goto st0;
+		goto tr16;
 	goto tr6;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+	switch( (*p) ) {
+		case 33: goto tr18;
+		case 95: goto tr18;
 	}
-	_test_eof3: cs = 3; goto _test_eof;
-	_test_eof4: cs = 4; goto _test_eof;
-	_test_eof5: cs = 5; goto _test_eof;
-	_test_eof6: cs = 6; goto _test_eof;
-	_test_eof2: cs = 2; goto _test_eof;
-	_test_eof7: cs = 7; goto _test_eof;
-	_test_eof8: cs = 8; goto _test_eof;
-	_test_eof9: cs = 9; goto _test_eof;
-
-	_test_eof: {}
-	if ( p == eof )
-	{
-	switch ( cs ) {
-	case 3:
-	case 7:
-	case 9:
-#line 412 "edn_parser.rl"
-	{
-        // stand-alone operators (-, +, /, ... etc)
-        char op[2] = { *p_save, 0 };
-        VALUE sym = rb_str_new2(op);
-        v = Parser::make_edn_symbol(sym);
-    }
+	if ( (*p) < 45 ) {
+		if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto tr18;
+		} else if ( (*p) >= 35 )
+			goto tr18;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto tr18;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto tr18;
+		} else
+			goto tr18;
+	} else
+		goto tr18;
+	goto tr17;
+tr18:
+#line 376 "edn_parser.rl"
+	{
+        // parse a symbol including the leading operator (-, +, .)
+        VALUE sym = Qnil;
+        const char *np = parse_symbol(p_save, pe, sym);
+        if (np == NULL) { {p = (( pe))-1;} } else {
+            if (sym != Qnil)
+                v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
+            {p = (( np))-1;}
+        }
+    }
+	goto st10;
+st10:
+	if ( ++p == pe )
+		goto _test_eof10;
+case 10:
+#line 1331 "edn_parser.cc"
+	switch( (*p) ) {
+		case 33: goto st10;
+		case 95: goto st10;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st10;
+		} else if ( (*p) >= 35 )
+			goto st10;
+	} else if ( (*p) > 58 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st10;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st10;
+		} else
+			goto st10;
+	} else
+		goto st10;
+	goto tr11;
+st11:
+	if ( ++p == pe )
+		goto _test_eof11;
+case 11:
+	switch( (*p) ) {
+		case 10: goto tr8;
+		case 32: goto tr7;
+		case 33: goto st9;
+		case 44: goto tr7;
+		case 59: goto tr10;
+		case 95: goto st9;
+	}
+	if ( (*p) < 48 ) {
+		if ( (*p) < 35 ) {
+			if ( 9 <= (*p) && (*p) <= 13 )
+				goto tr7;
+		} else if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 47 )
+				goto st9;
+		} else
+			goto st9;
+	} else if ( (*p) > 57 ) {
+		if ( (*p) < 65 ) {
+			if ( 58 <= (*p) && (*p) <= 63 )
+				goto st9;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st9;
+		} else
+			goto st9;
+	} else
+		goto st0;
+	goto tr6;
+	}
+	_test_eof3: cs = 3; goto _test_eof;
+	_test_eof4: cs = 4; goto _test_eof;
+	_test_eof5: cs = 5; goto _test_eof;
+	_test_eof6: cs = 6; goto _test_eof;
+	_test_eof2: cs = 2; goto _test_eof;
+	_test_eof7: cs = 7; goto _test_eof;
+	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof9: cs = 9; goto _test_eof;
+	_test_eof10: cs = 10; goto _test_eof;
+	_test_eof11: cs = 11; goto _test_eof;
+
+	_test_eof: {}
+	if ( p == eof )
+	{
+	switch ( cs ) {
+	case 9:
+#line 376 "edn_parser.rl"
+	{
+        // parse a symbol including the leading operator (-, +, .)
+        VALUE sym = Qnil;
+        const char *np = parse_symbol(p_save, pe, sym);
+        if (np == NULL) { {p = (( pe))-1;} } else {
+            if (sym != Qnil)
+                v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
+            {p = (( np))-1;}
+        }
+    }
+	break;
+	case 3:
+	case 8:
+	case 11:
+#line 410 "edn_parser.rl"
+	{
+        // stand-alone operators (-, +, /, ... etc)
+        char op[2] = { *p_save, 0 };
+        VALUE sym = rb_str_new2(op);
+        v = Parser::make_edn_type(EDNT_MAKE_SYMBOL_METHOD, sym);
+    }
 	break;
-#line 1307 "edn_parser.cc"
+#line 1427 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 435 "edn_parser.rl"
+#line 436 "edn_parser.rl"
 
     if (cs >= EDN_operator_first_final) {
         return p;
     }
     else if (cs == EDN_operator_error) {
-        error(__FUNCTION__, *p);
+        error(__FUNCTION__, "symbol syntax error", *p);
         return pe;
     }
     else if (cs == EDN_operator_en_main) {} // silence ragel warning
@@ -1329,15 +1449,15 @@ case 9:
 // escaped char parsing - handles \c, \newline, \formfeed, etc.
 //
 
-#line 1333 "edn_parser.cc"
+#line 1453 "edn_parser.cc"
 static const int EDN_escaped_char_start = 1;
-static const int EDN_escaped_char_first_final = 4;
+static const int EDN_escaped_char_first_final = 26;
 static const int EDN_escaped_char_error = 0;
 
 static const int EDN_escaped_char_en_main = 1;
 
 
-#line 464 "edn_parser.rl"
+#line 466 "edn_parser.rl"
 
 
 
@@ -1346,15 +1466,15 @@ const char* edn::Parser::parse_esc_char(const char *p, const char *pe, VALUE& v)
     int cs;
 
 
-#line 1350 "edn_parser.cc"
+#line 1470 "edn_parser.cc"
 	{
 	cs = EDN_escaped_char_start;
 	}
 
-#line 472 "edn_parser.rl"
+#line 474 "edn_parser.rl"
     const char* p_save = p;
 
-#line 1358 "edn_parser.cc"
+#line 1478 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1371,109 +1491,382 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-	if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st4;
-	} else if ( (*p) >= 65 )
-		goto st4;
+	switch( (*p) ) {
+		case 98: goto st29;
+		case 102: goto st30;
+		case 110: goto st31;
+		case 114: goto st32;
+		case 115: goto st33;
+		case 116: goto st34;
+	}
+	goto st26;
+st26:
+	if ( ++p == pe )
+		goto _test_eof26;
+case 26:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
+	goto st0;
+tr10:
+#line 20 "edn_parser.rl"
+	{ line_number++; }
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 27; goto _out;} }
+	goto st27;
+tr28:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 27; goto _out;} }
+	goto st27;
+st27:
+	if ( ++p == pe )
+		goto _test_eof27;
+case 27:
+#line 1536 "edn_parser.cc"
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 44: goto tr28;
+		case 59: goto st3;
+	}
+	if ( 9 <= (*p) && (*p) <= 13 )
+		goto tr28;
+	goto st0;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+	if ( (*p) == 10 )
+		goto tr10;
+	goto st3;
+tr29:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 28; goto _out;} }
+	goto st28;
+st28:
+	if ( ++p == pe )
+		goto _test_eof28;
+case 28:
+#line 1561 "edn_parser.cc"
+	goto st0;
+st29:
+	if ( ++p == pe )
+		goto _test_eof29;
+case 29:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 97: goto st4;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
 	goto st0;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-	switch( (*p) ) {
-		case 10: goto tr7;
-		case 32: goto tr6;
-		case 44: goto tr6;
-		case 59: goto tr8;
-		case 92: goto st0;
-	}
-	if ( (*p) < 65 ) {
-		if ( 9 <= (*p) && (*p) <= 13 )
-			goto tr6;
-	} else if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st4;
-	} else
-		goto st4;
-	goto tr5;
-tr5:
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 5; goto _out;} }
-	goto st5;
+	if ( (*p) == 99 )
+		goto st5;
+	goto st0;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 1409 "edn_parser.cc"
+	if ( (*p) == 107 )
+		goto st6;
 	goto st0;
-tr4:
-#line 20 "edn_parser.rl"
-	{ line_number++; }
-	goto st6;
-tr6:
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 6; goto _out;} }
-	goto st6;
-tr7:
-#line 20 "edn_parser.rl"
-	{ line_number++; }
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 6; goto _out;} }
-	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 1429 "edn_parser.cc"
-	switch( (*p) ) {
-		case 10: goto tr7;
-		case 32: goto tr6;
-		case 44: goto tr6;
-		case 59: goto tr8;
-		case 92: goto st0;
-	}
-	if ( (*p) < 65 ) {
-		if ( 9 <= (*p) && (*p) <= 13 )
-			goto tr6;
-	} else if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st0;
-	} else
-		goto st0;
-	goto tr5;
-tr8:
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 7; goto _out;} }
-	goto st7;
+	if ( (*p) == 115 )
+		goto st7;
+	goto st0;
 st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 1454 "edn_parser.cc"
-	if ( (*p) == 10 )
-		goto tr4;
-	goto st3;
-st3:
+	if ( (*p) == 112 )
+		goto st8;
+	goto st0;
+st8:
 	if ( ++p == pe )
-		goto _test_eof3;
-case 3:
-	if ( (*p) == 10 )
-		goto tr4;
-	goto st3;
+		goto _test_eof8;
+case 8:
+	if ( (*p) == 97 )
+		goto st9;
+	goto st0;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+	if ( (*p) == 99 )
+		goto st10;
+	goto st0;
+st10:
+	if ( ++p == pe )
+		goto _test_eof10;
+case 10:
+	if ( (*p) == 101 )
+		goto st26;
+	goto st0;
+st30:
+	if ( ++p == pe )
+		goto _test_eof30;
+case 30:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 111: goto st11;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
+	goto st0;
+st11:
+	if ( ++p == pe )
+		goto _test_eof11;
+case 11:
+	if ( (*p) == 114 )
+		goto st12;
+	goto st0;
+st12:
+	if ( ++p == pe )
+		goto _test_eof12;
+case 12:
+	if ( (*p) == 109 )
+		goto st13;
+	goto st0;
+st13:
+	if ( ++p == pe )
+		goto _test_eof13;
+case 13:
+	if ( (*p) == 102 )
+		goto st14;
+	goto st0;
+st14:
+	if ( ++p == pe )
+		goto _test_eof14;
+case 14:
+	if ( (*p) == 101 )
+		goto st15;
+	goto st0;
+st15:
+	if ( ++p == pe )
+		goto _test_eof15;
+case 15:
+	if ( (*p) == 101 )
+		goto st16;
+	goto st0;
+st16:
+	if ( ++p == pe )
+		goto _test_eof16;
+case 16:
+	if ( (*p) == 100 )
+		goto st26;
+	goto st0;
+st31:
+	if ( ++p == pe )
+		goto _test_eof31;
+case 31:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 101: goto st17;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
+	goto st0;
+st17:
+	if ( ++p == pe )
+		goto _test_eof17;
+case 17:
+	if ( (*p) == 119 )
+		goto st18;
+	goto st0;
+st18:
+	if ( ++p == pe )
+		goto _test_eof18;
+case 18:
+	if ( (*p) == 108 )
+		goto st19;
+	goto st0;
+st19:
+	if ( ++p == pe )
+		goto _test_eof19;
+case 19:
+	if ( (*p) == 105 )
+		goto st20;
+	goto st0;
+st20:
+	if ( ++p == pe )
+		goto _test_eof20;
+case 20:
+	if ( (*p) == 110 )
+		goto st10;
+	goto st0;
+st32:
+	if ( ++p == pe )
+		goto _test_eof32;
+case 32:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 101: goto st21;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
+	goto st0;
+st21:
+	if ( ++p == pe )
+		goto _test_eof21;
+case 21:
+	if ( (*p) == 116 )
+		goto st22;
+	goto st0;
+st22:
+	if ( ++p == pe )
+		goto _test_eof22;
+case 22:
+	if ( (*p) == 117 )
+		goto st23;
+	goto st0;
+st23:
+	if ( ++p == pe )
+		goto _test_eof23;
+case 23:
+	if ( (*p) == 114 )
+		goto st24;
+	goto st0;
+st24:
+	if ( ++p == pe )
+		goto _test_eof24;
+case 24:
+	if ( (*p) == 110 )
+		goto st26;
+	goto st0;
+st33:
+	if ( ++p == pe )
+		goto _test_eof33;
+case 33:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 112: goto st8;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
+	goto st0;
+st34:
+	if ( ++p == pe )
+		goto _test_eof34;
+case 34:
+	switch( (*p) ) {
+		case 10: goto tr10;
+		case 32: goto tr28;
+		case 41: goto tr29;
+		case 44: goto tr28;
+		case 59: goto st3;
+		case 97: goto st25;
+		case 125: goto tr29;
+	}
+	if ( (*p) > 13 ) {
+		if ( 92 <= (*p) && (*p) <= 93 )
+			goto tr29;
+	} else if ( (*p) >= 9 )
+		goto tr28;
+	goto st0;
+st25:
+	if ( ++p == pe )
+		goto _test_eof25;
+case 25:
+	if ( (*p) == 98 )
+		goto st26;
+	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
+	_test_eof26: cs = 26; goto _test_eof;
+	_test_eof27: cs = 27; goto _test_eof;
+	_test_eof3: cs = 3; goto _test_eof;
+	_test_eof28: cs = 28; goto _test_eof;
+	_test_eof29: cs = 29; goto _test_eof;
 	_test_eof4: cs = 4; goto _test_eof;
 	_test_eof5: cs = 5; goto _test_eof;
 	_test_eof6: cs = 6; goto _test_eof;
 	_test_eof7: cs = 7; goto _test_eof;
-	_test_eof3: cs = 3; goto _test_eof;
+	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof9: cs = 9; goto _test_eof;
+	_test_eof10: cs = 10; goto _test_eof;
+	_test_eof30: cs = 30; goto _test_eof;
+	_test_eof11: cs = 11; goto _test_eof;
+	_test_eof12: cs = 12; goto _test_eof;
+	_test_eof13: cs = 13; goto _test_eof;
+	_test_eof14: cs = 14; goto _test_eof;
+	_test_eof15: cs = 15; goto _test_eof;
+	_test_eof16: cs = 16; goto _test_eof;
+	_test_eof31: cs = 31; goto _test_eof;
+	_test_eof17: cs = 17; goto _test_eof;
+	_test_eof18: cs = 18; goto _test_eof;
+	_test_eof19: cs = 19; goto _test_eof;
+	_test_eof20: cs = 20; goto _test_eof;
+	_test_eof32: cs = 32; goto _test_eof;
+	_test_eof21: cs = 21; goto _test_eof;
+	_test_eof22: cs = 22; goto _test_eof;
+	_test_eof23: cs = 23; goto _test_eof;
+	_test_eof24: cs = 24; goto _test_eof;
+	_test_eof33: cs = 33; goto _test_eof;
+	_test_eof34: cs = 34; goto _test_eof;
+	_test_eof25: cs = 25; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 474 "edn_parser.rl"
+#line 476 "edn_parser.rl"
 
     if (cs >= EDN_escaped_char_first_final) {
         // convert the escaped value to a character
@@ -1483,7 +1876,7 @@ case 3:
         return p;
     }
     else if (cs == EDN_escaped_char_error) {
-        error(__FUNCTION__, *p);
+        error(__FUNCTION__, "unexpected value", *p);
         return pe;
     }
     else if (cs == EDN_escaped_char_en_main) {} // silence ragel warning
@@ -1500,15 +1893,15 @@ case 3:
 //
 //
 
-#line 1504 "edn_parser.cc"
+#line 1897 "edn_parser.cc"
 static const int EDN_symbol_start = 1;
-static const int EDN_symbol_first_final = 5;
+static const int EDN_symbol_first_final = 4;
 static const int EDN_symbol_error = 0;
 
 static const int EDN_symbol_en_main = 1;
 
 
-#line 509 "edn_parser.rl"
+#line 527 "edn_parser.rl"
 
 
 
@@ -1517,127 +1910,110 @@ const char* edn::Parser::parse_symbol(const char *p, const char *pe, VALUE& s)
     int cs;
 
 
-#line 1521 "edn_parser.cc"
+#line 1914 "edn_parser.cc"
 	{
 	cs = EDN_symbol_start;
 	}
 
-#line 517 "edn_parser.rl"
+#line 535 "edn_parser.rl"
     const char* p_save = p;
 
-#line 1529 "edn_parser.cc"
+#line 1922 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
-	switch ( cs )
-	{
-case 1:
-	switch( (*p) ) {
-		case 33: goto st2;
-		case 95: goto st2;
-	}
-	if ( (*p) < 45 ) {
-		if ( (*p) > 38 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto st2;
-		} else if ( (*p) >= 36 )
-			goto st2;
-	} else if ( (*p) > 47 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st2;
-		} else if ( (*p) > 90 ) {
-			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st5;
-		} else
-			goto st5;
-	} else
-		goto st2;
-	goto st0;
-st0:
-cs = 0;
-	goto _out;
-st2:
-	if ( ++p == pe )
-		goto _test_eof2;
-case 2:
-	if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st5;
-	} else if ( (*p) >= 65 )
-		goto st5;
-	goto st0;
-st5:
-	if ( ++p == pe )
-		goto _test_eof5;
-case 5:
+	switch ( cs )
+	{
+case 1:
 	switch( (*p) ) {
-		case 10: goto tr8;
-		case 32: goto tr7;
-		case 33: goto st0;
-		case 35: goto st5;
-		case 39: goto st5;
-		case 44: goto tr7;
-		case 47: goto st4;
-		case 59: goto tr10;
-		case 95: goto st5;
+		case 33: goto st4;
+		case 47: goto st9;
+		case 95: goto st4;
 	}
 	if ( (*p) < 45 ) {
-		if ( (*p) < 36 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto tr7;
-		} else if ( (*p) > 38 ) {
+		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto st0;
-		} else
-			goto st0;
-	} else if ( (*p) > 58 ) {
+				goto st4;
+		} else if ( (*p) >= 36 )
+			goto st4;
+	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 60 <= (*p) && (*p) <= 63 )
-				goto st0;
+				goto st4;
 		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st5;
+				goto st4;
 		} else
-			goto st5;
+			goto st4;
 	} else
-		goto st5;
-	goto tr6;
-tr6:
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 6; goto _out;} }
-	goto st6;
-st6:
+		goto st4;
+	goto st0;
+st0:
+cs = 0;
+	goto _out;
+st4:
 	if ( ++p == pe )
-		goto _test_eof6;
-case 6:
-#line 1615 "edn_parser.cc"
+		goto _test_eof4;
+case 4:
+	switch( (*p) ) {
+		case 10: goto tr9;
+		case 32: goto tr8;
+		case 33: goto st4;
+		case 44: goto tr8;
+		case 47: goto st3;
+		case 59: goto tr11;
+		case 95: goto st4;
+	}
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 39 )
+				goto st4;
+		} else if ( (*p) >= 9 )
+			goto tr8;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st4;
+		} else if ( (*p) >= 65 )
+			goto st4;
+	} else
+		goto st4;
+	goto tr7;
+tr7:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 5; goto _out;} }
+	goto st5;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+#line 1991 "edn_parser.cc"
 	goto st0;
 tr4:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
-	goto st7;
-tr7:
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 7; goto _out;} }
-	goto st7;
+	goto st6;
 tr8:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+tr9:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 7; goto _out;} }
-	goto st7;
-st7:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 6; goto _out;} }
+	goto st6;
+st6:
 	if ( ++p == pe )
-		goto _test_eof7;
-case 7:
-#line 1635 "edn_parser.cc"
+		goto _test_eof6;
+case 6:
+#line 2011 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr8;
-		case 32: goto tr7;
+		case 10: goto tr9;
+		case 32: goto tr8;
 		case 33: goto st0;
-		case 44: goto tr7;
-		case 59: goto tr10;
+		case 44: goto tr8;
+		case 59: goto tr11;
 		case 95: goto st0;
 	}
 	if ( (*p) < 42 ) {
@@ -1645,7 +2021,7 @@ case 7:
 			if ( 35 <= (*p) && (*p) <= 39 )
 				goto st0;
 		} else if ( (*p) >= 9 )
-			goto tr7;
+			goto tr8;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
@@ -1654,87 +2030,124 @@ case 7:
 			goto st0;
 	} else
 		goto st0;
-	goto tr6;
-tr10:
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 8; goto _out;} }
-	goto st8;
-st8:
+	goto tr7;
+tr11:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 7; goto _out;} }
+	goto st7;
+st7:
 	if ( ++p == pe )
-		goto _test_eof8;
-case 8:
-#line 1667 "edn_parser.cc"
+		goto _test_eof7;
+case 7:
+#line 2043 "edn_parser.cc"
 	if ( (*p) == 10 )
 		goto tr4;
-	goto st3;
-st3:
+	goto st2;
+st2:
 	if ( ++p == pe )
-		goto _test_eof3;
-case 3:
+		goto _test_eof2;
+case 2:
 	if ( (*p) == 10 )
 		goto tr4;
-	goto st3;
-st4:
+	goto st2;
+st3:
 	if ( ++p == pe )
-		goto _test_eof4;
-case 4:
-	if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st9;
-	} else if ( (*p) >= 65 )
-		goto st9;
+		goto _test_eof3;
+case 3:
+	switch( (*p) ) {
+		case 33: goto st8;
+		case 47: goto st6;
+		case 95: goto st8;
+	}
+	if ( (*p) < 45 ) {
+		if ( (*p) > 39 ) {
+			if ( 42 <= (*p) && (*p) <= 43 )
+				goto st8;
+		} else if ( (*p) >= 36 )
+			goto st8;
+	} else if ( (*p) > 46 ) {
+		if ( (*p) < 65 ) {
+			if ( 60 <= (*p) && (*p) <= 63 )
+				goto st8;
+		} else if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st8;
+		} else
+			goto st8;
+	} else
+		goto st8;
 	goto st0;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+	switch( (*p) ) {
+		case 10: goto tr9;
+		case 32: goto tr8;
+		case 33: goto st8;
+		case 44: goto tr8;
+		case 47: goto st0;
+		case 59: goto tr11;
+		case 95: goto st8;
+	}
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 39 )
+				goto st8;
+		} else if ( (*p) >= 9 )
+			goto tr8;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st8;
+		} else if ( (*p) >= 65 )
+			goto st8;
+	} else
+		goto st8;
+	goto tr7;
 st9:
 	if ( ++p == pe )
 		goto _test_eof9;
 case 9:
 	switch( (*p) ) {
-		case 10: goto tr8;
-		case 32: goto tr7;
+		case 10: goto tr9;
+		case 32: goto tr8;
 		case 33: goto st0;
-		case 35: goto st9;
-		case 39: goto st9;
-		case 44: goto tr7;
-		case 47: goto st0;
-		case 59: goto tr10;
-		case 95: goto st9;
+		case 44: goto tr8;
+		case 47: goto st3;
+		case 59: goto tr11;
+		case 95: goto st0;
 	}
-	if ( (*p) < 45 ) {
-		if ( (*p) < 36 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto tr7;
-		} else if ( (*p) > 38 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto st0;
-		} else
-			goto st0;
-	} else if ( (*p) > 58 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 39 )
 				goto st0;
-		} else if ( (*p) > 90 ) {
+		} else if ( (*p) >= 9 )
+			goto tr8;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st9;
-		} else
-			goto st9;
+				goto st0;
+		} else if ( (*p) >= 65 )
+			goto st0;
 	} else
-		goto st9;
-	goto tr6;
+		goto st0;
+	goto tr7;
 	}
-	_test_eof2: cs = 2; goto _test_eof;
+	_test_eof4: cs = 4; goto _test_eof;
 	_test_eof5: cs = 5; goto _test_eof;
 	_test_eof6: cs = 6; goto _test_eof;
 	_test_eof7: cs = 7; goto _test_eof;
-	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof2: cs = 2; goto _test_eof;
 	_test_eof3: cs = 3; goto _test_eof;
-	_test_eof4: cs = 4; goto _test_eof;
+	_test_eof8: cs = 8; goto _test_eof;
 	_test_eof9: cs = 9; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 519 "edn_parser.rl"
+#line 537 "edn_parser.rl"
 
     if (cs >= EDN_symbol_first_final) {
         // copy the symbol text
@@ -1744,8 +2157,7 @@ case 9:
         return p;
     }
     else if (cs == EDN_symbol_error) {
-        error(__FUNCTION__, *p);
-        return pe;
+        error(__FUNCTION__, "invalid symbol sequence", *p);
     }
     else if (cs == EDN_symbol_en_main) {} // silence ragel warning
     return NULL;
@@ -1760,13 +2172,13 @@ case 9:
 // sets the same array is used)
 //
 
-#line 575 "edn_parser.rl"
+#line 615 "edn_parser.rl"
 
 
 //
 // vector-specific machine
 
-#line 1770 "edn_parser.cc"
+#line 2182 "edn_parser.cc"
 static const int EDN_vector_start = 1;
 static const int EDN_vector_first_final = 4;
 static const int EDN_vector_error = 0;
@@ -1774,7 +2186,7 @@ static const int EDN_vector_error = 0;
 static const int EDN_vector_en_main = 1;
 
 
-#line 591 "edn_parser.rl"
+#line 630 "edn_parser.rl"
 
 
 
@@ -1786,17 +2198,17 @@ const char* edn::Parser::parse_vector(const char *p, const char *pe, VALUE& v)
     static const char* EDN_TYPE = "vector";
 
     int cs;
-    VALUE elems = rb_ary_new(); // will store the vector's elements
+    VALUE elems; // will store the vector's elements - allocated in @open_seq
 
 
-#line 1793 "edn_parser.cc"
+#line 2205 "edn_parser.cc"
 	{
 	cs = EDN_vector_start;
 	}
 
-#line 605 "edn_parser.rl"
+#line 644 "edn_parser.rl"
 
-#line 1800 "edn_parser.cc"
+#line 2212 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1804,10 +2216,10 @@ const char* edn::Parser::parse_vector(const char *p, const char *pe, VALUE& v)
 	{
 case 1:
 	if ( (*p) == 91 )
-		goto st2;
+		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1815,35 +2227,55 @@ tr2:
             p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 1819 "edn_parser.cc"
+#line 2231 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
-tr3:
+tr0:
+#line 564 "edn_parser.rl"
+	{
+        // sequences store elements in an array, then process it to
+        // convert it to a list, set, or map as needed once the
+        // sequence end is reached
+        elems = rb_ary_new();
+        // additionally, metadata for elements in the sequence may be
+        // carried so we must push a new level in the metadata stack
+        new_meta_list();
+    }
+	goto st2;
+tr4:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
-tr4:
-#line 547 "edn_parser.rl"
+tr5:
+#line 579 "edn_parser.rl"
 	{
         // reads an item within a sequence (vector, list, map, or
         // set). Regardless of the sequence type, an array of the
         // items is built. Once done, the sequence parser will convert
         // if needed
         VALUE e;
+        std::size_t meta_sz = meta_size();
         const char *np = parse_value(p, pe, e);
-        if (np == NULL) {
-            p--; {p++; cs = 2; goto _out;}
-        } else {
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
             // if there's an entry in the discard list, the current
             // object is not meant to be kept due to a #_ so don't
             // push it into the list of elements
             if (!discard.empty()) {
                 discard.pop_back();
             }
-            else {
-                // otherwise we add it to the list of elements for the
-                // corresponding container
+            else if (!meta_empty()) {
+                // check if parse_value added metadata
+                if (meta_size() == meta_sz) {
+                    // there's metadata and it didn't increase so
+                    // parse_value() read an element we care
+                    // about. Bind the metadata to it and add it to
+                    // the sequence
+                    e = Parser::make_edn_type(EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+                    rb_ary_push(elems, e);
+                }
+            } else {
+                // no metadata.. just push it
                 rb_ary_push(elems, e);
             }
             {p = (( np))-1;}
@@ -1854,46 +2286,50 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 1858 "edn_parser.cc"
+#line 2290 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr3;
+		case 10: goto tr4;
 		case 32: goto st2;
-		case 40: goto tr4;
 		case 44: goto st2;
 		case 59: goto st3;
-		case 93: goto tr6;
+		case 93: goto tr7;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
-				goto tr4;
+			if ( 33 <= (*p) && (*p) <= 40 )
+				goto tr5;
 		} else if ( (*p) >= 9 )
 			goto st2;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) > 95 ) {
 			if ( 97 <= (*p) && (*p) <= 123 )
-				goto tr4;
+				goto tr5;
 		} else if ( (*p) >= 65 )
-			goto tr4;
+			goto tr5;
 	} else
-		goto tr4;
+		goto tr5;
 	goto tr2;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
 	if ( (*p) == 10 )
-		goto tr3;
+		goto tr4;
 	goto st3;
-tr6:
-#line 58 "edn_parser.rl"
+tr7:
+#line 574 "edn_parser.rl"
+	{
+        // remove the current metadata level
+        del_top_meta_list();
+    }
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1897 "edn_parser.cc"
+#line 2333 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -1906,7 +2342,7 @@ case 4:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1914,21 +2350,21 @@ case 4:
             p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 1918 "edn_parser.cc"
+#line 2354 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 606 "edn_parser.rl"
+#line 645 "edn_parser.rl"
 
     if (cs >= EDN_vector_first_final) {
         v = elems;
         return p + 1;
     }
     else if (cs == EDN_vector_error) {
-        error(__FUNCTION__, *p);
+        error(__FUNCTION__, "vector format error", *p);
         return pe;
     }
     else if (cs == EDN_vector_en_main) {} // silence ragel warning
@@ -1941,7 +2377,7 @@ case 4:
 // list parsing machine
 //
 
-#line 1945 "edn_parser.cc"
+#line 2381 "edn_parser.cc"
 static const int EDN_list_start = 1;
 static const int EDN_list_first_final = 4;
 static const int EDN_list_error = 0;
@@ -1949,7 +2385,7 @@ static const int EDN_list_error = 0;
 static const int EDN_list_en_main = 1;
 
 
-#line 635 "edn_parser.rl"
+#line 674 "edn_parser.rl"
 
 
 //
@@ -1960,17 +2396,17 @@ const char* edn::Parser::parse_list(const char *p, const char *pe, VALUE& v)
     static const char* EDN_TYPE = "list";
 
     int cs;
-    VALUE elems = rb_ary_new();
+    VALUE elems; // stores the list's elements - allocated in @open_seq
 
 
-#line 1967 "edn_parser.cc"
+#line 2403 "edn_parser.cc"
 	{
 	cs = EDN_list_start;
 	}
 
-#line 648 "edn_parser.rl"
+#line 687 "edn_parser.rl"
 
-#line 1974 "edn_parser.cc"
+#line 2410 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1978,10 +2414,10 @@ const char* edn::Parser::parse_list(const char *p, const char *pe, VALUE& v)
 	{
 case 1:
 	if ( (*p) == 40 )
-		goto st2;
+		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -1989,35 +2425,55 @@ tr2:
             p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 1993 "edn_parser.cc"
+#line 2429 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
-tr3:
+tr0:
+#line 564 "edn_parser.rl"
+	{
+        // sequences store elements in an array, then process it to
+        // convert it to a list, set, or map as needed once the
+        // sequence end is reached
+        elems = rb_ary_new();
+        // additionally, metadata for elements in the sequence may be
+        // carried so we must push a new level in the metadata stack
+        new_meta_list();
+    }
+	goto st2;
+tr4:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
-tr4:
-#line 547 "edn_parser.rl"
+tr5:
+#line 579 "edn_parser.rl"
 	{
         // reads an item within a sequence (vector, list, map, or
         // set). Regardless of the sequence type, an array of the
         // items is built. Once done, the sequence parser will convert
         // if needed
         VALUE e;
+        std::size_t meta_sz = meta_size();
         const char *np = parse_value(p, pe, e);
-        if (np == NULL) {
-            p--; {p++; cs = 2; goto _out;}
-        } else {
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
             // if there's an entry in the discard list, the current
             // object is not meant to be kept due to a #_ so don't
             // push it into the list of elements
             if (!discard.empty()) {
                 discard.pop_back();
             }
-            else {
-                // otherwise we add it to the list of elements for the
-                // corresponding container
+            else if (!meta_empty()) {
+                // check if parse_value added metadata
+                if (meta_size() == meta_sz) {
+                    // there's metadata and it didn't increase so
+                    // parse_value() read an element we care
+                    // about. Bind the metadata to it and add it to
+                    // the sequence
+                    e = Parser::make_edn_type(EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+                    rb_ary_push(elems, e);
+                }
+            } else {
+                // no metadata.. just push it
                 rb_ary_push(elems, e);
             }
             {p = (( np))-1;}
@@ -2028,48 +2484,50 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2032 "edn_parser.cc"
+#line 2488 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr3;
+		case 10: goto tr4;
 		case 32: goto st2;
-		case 41: goto tr5;
+		case 41: goto tr6;
 		case 44: goto st2;
 		case 59: goto st3;
 	}
-	if ( (*p) < 40 ) {
+	if ( (*p) < 65 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
-				goto tr4;
+			if ( 33 <= (*p) && (*p) <= 63 )
+				goto tr5;
 		} else if ( (*p) >= 9 )
 			goto st2;
-	} else if ( (*p) > 63 ) {
-		if ( (*p) < 94 ) {
-			if ( 65 <= (*p) && (*p) <= 92 )
-				goto tr4;
-		} else if ( (*p) > 95 ) {
+	} else if ( (*p) > 92 ) {
+		if ( (*p) > 95 ) {
 			if ( 97 <= (*p) && (*p) <= 123 )
-				goto tr4;
-		} else
-			goto tr4;
+				goto tr5;
+		} else if ( (*p) >= 94 )
+			goto tr5;
 	} else
-		goto tr4;
+		goto tr5;
 	goto tr2;
-tr5:
-#line 58 "edn_parser.rl"
+tr6:
+#line 574 "edn_parser.rl"
+	{
+        // remove the current metadata level
+        del_top_meta_list();
+    }
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2066 "edn_parser.cc"
+#line 2524 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
 	if ( (*p) == 10 )
-		goto tr3;
+		goto tr4;
 	goto st3;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2082,7 +2540,7 @@ case 3:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -2090,17 +2548,19 @@ case 3:
             p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 2094 "edn_parser.cc"
+#line 2552 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 649 "edn_parser.rl"
+#line 688 "edn_parser.rl"
 
     if (cs >= EDN_list_first_final) {
         v = elems;
+        // TODO: replace with this but first figure out why array is not unrolled by EDN::list()
+        //        v = Parser::make_edn_type(EDNT_MAKE_LIST_METHOD, elems);
         return p + 1;
     }
     else if (cs == EDN_list_error) {
@@ -2117,7 +2577,7 @@ case 3:
 // hash parsing
 //
 
-#line 2121 "edn_parser.cc"
+#line 2581 "edn_parser.cc"
 static const int EDN_map_start = 1;
 static const int EDN_map_first_final = 4;
 static const int EDN_map_error = 0;
@@ -2125,7 +2585,7 @@ static const int EDN_map_error = 0;
 static const int EDN_map_en_main = 1;
 
 
-#line 679 "edn_parser.rl"
+#line 720 "edn_parser.rl"
 
 
 
@@ -2135,18 +2595,18 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, VALUE& v)
 
     int cs;
     // since we don't know whether we're looking at a key or value,
-    // initially store all elements in a list
-    VALUE elems = rb_ary_new();
+    // initially store all elements in an array (allocated in @open_seq)
+    VALUE elems;
 
 
-#line 2143 "edn_parser.cc"
+#line 2603 "edn_parser.cc"
 	{
 	cs = EDN_map_start;
 	}
 
-#line 692 "edn_parser.rl"
+#line 733 "edn_parser.rl"
 
-#line 2150 "edn_parser.cc"
+#line 2610 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2154,10 +2614,10 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, VALUE& v)
 	{
 case 1:
 	if ( (*p) == 123 )
-		goto st2;
+		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -2165,35 +2625,55 @@ tr2:
             p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 2169 "edn_parser.cc"
+#line 2629 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
-tr3:
+tr0:
+#line 564 "edn_parser.rl"
+	{
+        // sequences store elements in an array, then process it to
+        // convert it to a list, set, or map as needed once the
+        // sequence end is reached
+        elems = rb_ary_new();
+        // additionally, metadata for elements in the sequence may be
+        // carried so we must push a new level in the metadata stack
+        new_meta_list();
+    }
+	goto st2;
+tr4:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
-tr4:
-#line 547 "edn_parser.rl"
+tr5:
+#line 579 "edn_parser.rl"
 	{
         // reads an item within a sequence (vector, list, map, or
         // set). Regardless of the sequence type, an array of the
         // items is built. Once done, the sequence parser will convert
         // if needed
         VALUE e;
+        std::size_t meta_sz = meta_size();
         const char *np = parse_value(p, pe, e);
-        if (np == NULL) {
-            p--; {p++; cs = 2; goto _out;}
-        } else {
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
             // if there's an entry in the discard list, the current
             // object is not meant to be kept due to a #_ so don't
             // push it into the list of elements
             if (!discard.empty()) {
                 discard.pop_back();
             }
-            else {
-                // otherwise we add it to the list of elements for the
-                // corresponding container
+            else if (!meta_empty()) {
+                // check if parse_value added metadata
+                if (meta_size() == meta_sz) {
+                    // there's metadata and it didn't increase so
+                    // parse_value() read an element we care
+                    // about. Bind the metadata to it and add it to
+                    // the sequence
+                    e = Parser::make_edn_type(EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+                    rb_ary_push(elems, e);
+                }
+            } else {
+                // no metadata.. just push it
                 rb_ary_push(elems, e);
             }
             {p = (( np))-1;}
@@ -2204,49 +2684,53 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2208 "edn_parser.cc"
+#line 2688 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr3;
+		case 10: goto tr4;
 		case 32: goto st2;
-		case 40: goto tr4;
 		case 44: goto st2;
 		case 59: goto st3;
-		case 125: goto tr6;
+		case 125: goto tr7;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
-				goto tr4;
+			if ( 33 <= (*p) && (*p) <= 40 )
+				goto tr5;
 		} else if ( (*p) >= 9 )
 			goto st2;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) < 94 ) {
 			if ( 65 <= (*p) && (*p) <= 92 )
-				goto tr4;
+				goto tr5;
 		} else if ( (*p) > 95 ) {
 			if ( 97 <= (*p) && (*p) <= 123 )
-				goto tr4;
+				goto tr5;
 		} else
-			goto tr4;
+			goto tr5;
 	} else
-		goto tr4;
+		goto tr5;
 	goto tr2;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
 	if ( (*p) == 10 )
-		goto tr3;
+		goto tr4;
 	goto st3;
-tr6:
-#line 58 "edn_parser.rl"
+tr7:
+#line 574 "edn_parser.rl"
+	{
+        // remove the current metadata level
+        del_top_meta_list();
+    }
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2250 "edn_parser.cc"
+#line 2734 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2259,7 +2743,7 @@ case 4:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -2267,14 +2751,14 @@ case 4:
             p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 2271 "edn_parser.cc"
+#line 2755 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 693 "edn_parser.rl"
+#line 734 "edn_parser.rl"
 
     if (cs >= EDN_map_first_final) {
 
@@ -2310,7 +2794,7 @@ case 4:
 // the remaining data to the correct parser
 //
 
-#line 2314 "edn_parser.cc"
+#line 2798 "edn_parser.cc"
 static const int EDN_dispatch_start = 1;
 static const int EDN_dispatch_first_final = 2;
 static const int EDN_dispatch_error = 0;
@@ -2318,7 +2802,7 @@ static const int EDN_dispatch_error = 0;
 static const int EDN_dispatch_en_main = 1;
 
 
-#line 757 "edn_parser.rl"
+#line 798 "edn_parser.rl"
 
 
 
@@ -2327,14 +2811,14 @@ const char* edn::Parser::parse_dispatch(const char *p, const char *pe, VALUE& v)
     int cs;
 
 
-#line 2331 "edn_parser.cc"
+#line 2815 "edn_parser.cc"
 	{
 	cs = EDN_dispatch_start;
 	}
 
-#line 765 "edn_parser.rl"
+#line 806 "edn_parser.rl"
 
-#line 2338 "edn_parser.cc"
+#line 2822 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2355,40 +2839,40 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 745 "edn_parser.rl"
+#line 786 "edn_parser.rl"
 	{
         // #inst, #uuid, or #user/tag
         const char *np = parse_tagged(p, pe, v);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr2:
-#line 739 "edn_parser.rl"
+#line 780 "edn_parser.rl"
 	{
         // discard token #_
         const char *np = parse_discard(p, pe);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr3:
-#line 733 "edn_parser.rl"
+#line 774 "edn_parser.rl"
 	{
         // #{ }
         const char *np = parse_set(p, pe, v);
         if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2392 "edn_parser.cc"
+#line 2876 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2397,13 +2881,13 @@ case 2:
 	_out: {}
 	}
 
-#line 766 "edn_parser.rl"
+#line 807 "edn_parser.rl"
 
     if (cs >= EDN_dispatch_first_final) {
         return p + 1;
     }
     else if (cs == EDN_dispatch_error) {
-        error(__FUNCTION__, *p);
+        error(__FUNCTION__, "dispatch extend error", *p);
         return pe;
     }
     else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
@@ -2416,7 +2900,7 @@ case 2:
 // set parsing machine
 //
 
-#line 2420 "edn_parser.cc"
+#line 2904 "edn_parser.cc"
 static const int EDN_set_start = 1;
 static const int EDN_set_first_final = 4;
 static const int EDN_set_error = 0;
@@ -2424,7 +2908,7 @@ static const int EDN_set_error = 0;
 static const int EDN_set_en_main = 1;
 
 
-#line 795 "edn_parser.rl"
+#line 836 "edn_parser.rl"
 
 
 //
@@ -2435,17 +2919,17 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, VALUE& v)
     static const char* EDN_TYPE = "set";
 
     int cs;
-    VALUE elems = rb_ary_new(); // stored as an array
+    VALUE elems; // holds the set's elements as an array allocated in @open_seq
 
 
-#line 2442 "edn_parser.cc"
+#line 2926 "edn_parser.cc"
 	{
 	cs = EDN_set_start;
 	}
 
-#line 808 "edn_parser.rl"
+#line 849 "edn_parser.rl"
 
-#line 2449 "edn_parser.cc"
+#line 2933 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2453,10 +2937,10 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, VALUE& v)
 	{
 case 1:
 	if ( (*p) == 123 )
-		goto st2;
+		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -2464,35 +2948,55 @@ tr2:
             p--; {p++; cs = 0; goto _out;}
         }
 	goto st0;
-#line 2468 "edn_parser.cc"
+#line 2952 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
-tr3:
+tr0:
+#line 564 "edn_parser.rl"
+	{
+        // sequences store elements in an array, then process it to
+        // convert it to a list, set, or map as needed once the
+        // sequence end is reached
+        elems = rb_ary_new();
+        // additionally, metadata for elements in the sequence may be
+        // carried so we must push a new level in the metadata stack
+        new_meta_list();
+    }
+	goto st2;
+tr4:
 #line 20 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
-tr4:
-#line 547 "edn_parser.rl"
+tr5:
+#line 579 "edn_parser.rl"
 	{
         // reads an item within a sequence (vector, list, map, or
         // set). Regardless of the sequence type, an array of the
         // items is built. Once done, the sequence parser will convert
         // if needed
         VALUE e;
+        std::size_t meta_sz = meta_size();
         const char *np = parse_value(p, pe, e);
-        if (np == NULL) {
-            p--; {p++; cs = 2; goto _out;}
-        } else {
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
             // if there's an entry in the discard list, the current
             // object is not meant to be kept due to a #_ so don't
             // push it into the list of elements
             if (!discard.empty()) {
                 discard.pop_back();
             }
-            else {
-                // otherwise we add it to the list of elements for the
-                // corresponding container
+            else if (!meta_empty()) {
+                // check if parse_value added metadata
+                if (meta_size() == meta_sz) {
+                    // there's metadata and it didn't increase so
+                    // parse_value() read an element we care
+                    // about. Bind the metadata to it and add it to
+                    // the sequence
+                    e = Parser::make_edn_type(EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+                    rb_ary_push(elems, e);
+                }
+            } else {
+                // no metadata.. just push it
                 rb_ary_push(elems, e);
             }
             {p = (( np))-1;}
@@ -2503,49 +3007,53 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2507 "edn_parser.cc"
+#line 3011 "edn_parser.cc"
 	switch( (*p) ) {
-		case 10: goto tr3;
+		case 10: goto tr4;
 		case 32: goto st2;
-		case 40: goto tr4;
 		case 44: goto st2;
 		case 59: goto st3;
-		case 125: goto tr6;
+		case 125: goto tr7;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
-				goto tr4;
+			if ( 33 <= (*p) && (*p) <= 40 )
+				goto tr5;
 		} else if ( (*p) >= 9 )
 			goto st2;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) < 94 ) {
 			if ( 65 <= (*p) && (*p) <= 92 )
-				goto tr4;
+				goto tr5;
 		} else if ( (*p) > 95 ) {
 			if ( 97 <= (*p) && (*p) <= 123 )
-				goto tr4;
+				goto tr5;
 		} else
-			goto tr4;
+			goto tr5;
 	} else
-		goto tr4;
+		goto tr5;
 	goto tr2;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
 	if ( (*p) == 10 )
-		goto tr3;
+		goto tr4;
 	goto st3;
-tr6:
-#line 58 "edn_parser.rl"
+tr7:
+#line 574 "edn_parser.rl"
+	{
+        // remove the current metadata level
+        del_top_meta_list();
+    }
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2549 "edn_parser.cc"
+#line 3057 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2558,7 +3066,7 @@ case 4:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#line 46 "edn_parser.rl"
 	{
             std::stringstream s;
             s << "unterminated " << EDN_TYPE;
@@ -2566,18 +3074,18 @@ case 4:
             p--; {p++; cs = 0; goto _out;}
         }
 	break;
-#line 2570 "edn_parser.cc"
+#line 3078 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 809 "edn_parser.rl"
+#line 850 "edn_parser.rl"
 
     if (cs >= EDN_set_first_final) {
         // all elements collected; now convert to a set
-        v = Parser::make_ruby_set(elems);
+        v = Parser::make_edn_type(EDNT_MAKE_SET_METHOD, elems);
         return p + 1;
     }
     else if (cs == EDN_set_error) {
@@ -2596,7 +3104,7 @@ case 4:
 // defining a machine to consume items within container delimiters
 //
 
-#line 2600 "edn_parser.cc"
+#line 3108 "edn_parser.cc"
 static const int EDN_discard_start = 1;
 static const int EDN_discard_first_final = 4;
 static const int EDN_discard_error = 0;
@@ -2604,7 +3112,7 @@ static const int EDN_discard_error = 0;
 static const int EDN_discard_en_main = 1;
 
 
-#line 861 "edn_parser.rl"
+#line 900 "edn_parser.rl"
 
 
 
@@ -2614,14 +3122,14 @@ const char* edn::Parser::parse_discard(const char *p, const char *pe)
     VALUE v;
 
 
-#line 2618 "edn_parser.cc"
+#line 3126 "edn_parser.cc"
 	{
 	cs = EDN_discard_start;
 	}
 
-#line 870 "edn_parser.rl"
+#line 909 "edn_parser.rl"
 
-#line 2625 "edn_parser.cc"
+#line 3133 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2632,7 +3140,7 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 851 "edn_parser.rl"
+#line 890 "edn_parser.rl"
 	{
         std::stringstream s;
         s << "discard sequence without element to discard";
@@ -2640,7 +3148,7 @@ tr2:
         p--; {p++; cs = 0; goto _out;}
     }
 	goto st0;
-#line 2644 "edn_parser.cc"
+#line 3152 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -2652,17 +3160,16 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2656 "edn_parser.cc"
+#line 3164 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
-		case 40: goto tr4;
 		case 44: goto st2;
 		case 59: goto st3;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+			if ( 33 <= (*p) && (*p) <= 40 )
 				goto tr4;
 		} else if ( (*p) >= 9 )
 			goto st2;
@@ -2679,27 +3186,25 @@ case 2:
 		goto tr4;
 	goto tr2;
 tr4:
-#line 838 "edn_parser.rl"
+#line 879 "edn_parser.rl"
 	{
         const char *np = parse_value(p, pe, v);
-        if (np) {
-            // this token is to be discard it so store it in the
+        if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {
+            // this token is to be discarded so store it in the
             // discard stack - we really don't need to save it so this
             // could be simplified
             discard.push_back(v);
             {p = (( np))-1;}
-        } else {
-            p--; {p++; cs = 4; goto _out;}
         }
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2703 "edn_parser.cc"
+#line 3208 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -2718,7 +3223,7 @@ case 3:
 	{
 	switch ( cs ) {
 	case 2:
-#line 851 "edn_parser.rl"
+#line 890 "edn_parser.rl"
 	{
         std::stringstream s;
         s << "discard sequence without element to discard";
@@ -2726,14 +3231,14 @@ case 3:
         p--; {p++; cs = 0; goto _out;}
     }
 	break;
-#line 2730 "edn_parser.cc"
+#line 3235 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 871 "edn_parser.rl"
+#line 910 "edn_parser.rl"
 
     if (cs >= EDN_discard_first_final) {
         return p + 1;
@@ -2764,15 +3269,15 @@ case 3:
 // 2. add parse checks for uuid and inst for better error reporting
 //
 
-#line 2768 "edn_parser.cc"
+#line 3273 "edn_parser.cc"
 static const int EDN_tagged_start = 1;
-static const int EDN_tagged_first_final = 6;
+static const int EDN_tagged_first_final = 7;
 static const int EDN_tagged_error = 0;
 
 static const int EDN_tagged_en_main = 1;
 
 
-#line 922 "edn_parser.rl"
+#line 978 "edn_parser.rl"
 
 
 
@@ -2780,18 +3285,20 @@ const char* edn::Parser::parse_tagged(const char *p, const char *pe, VALUE& v)
 {
     VALUE sym_name = Qnil;
     VALUE data = Qnil;
+    bool sym_ok = false;
+    bool data_ok = false;
 
     int cs;
 
 
-#line 2788 "edn_parser.cc"
+#line 3295 "edn_parser.cc"
 	{
 	cs = EDN_tagged_start;
 	}
 
-#line 933 "edn_parser.rl"
+#line 991 "edn_parser.rl"
 
-#line 2795 "edn_parser.cc"
+#line 3302 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2808,53 +3315,44 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 909 "edn_parser.rl"
+#line 957 "edn_parser.rl"
 	{
         // parses the symbol portion of the pair
         const char *np = parse_symbol(p, pe, sym_name);
-        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else { {p = (( np))-1;} }
+        if (np == NULL) { p--; {p++; cs = 2; goto _out;} } else {
+            sym_ok = true;
+            {p = (( np))-1;}
+        }
     }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2823 "edn_parser.cc"
+#line 3333 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
-		case 35: goto tr5;
-		case 39: goto st2;
+		case 33: goto st2;
 		case 44: goto st3;
-		case 47: goto tr7;
+		case 47: goto st5;
 		case 59: goto st4;
-		case 94: goto tr4;
-		case 95: goto tr5;
-		case 123: goto tr4;
+		case 95: goto st2;
 	}
-	if ( (*p) < 45 ) {
-		if ( (*p) < 33 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto st3;
-		} else if ( (*p) > 40 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr4;
-		} else
-			goto tr4;
-	} else if ( (*p) > 58 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto tr4;
-		} else if ( (*p) > 90 ) {
-			if ( (*p) > 92 ) {
-				if ( 97 <= (*p) && (*p) <= 122 )
-					goto tr5;
-			} else if ( (*p) >= 91 )
-				goto tr4;
-		} else
-			goto tr5;
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 39 )
+				goto st2;
+		} else if ( (*p) >= 9 )
+			goto st3;
+	} else if ( (*p) > 63 ) {
+		if ( (*p) > 90 ) {
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st2;
+		} else if ( (*p) >= 65 )
+			goto st2;
 	} else
-		goto tr5;
+		goto st2;
 	goto st0;
 tr3:
 #line 20 "edn_parser.rl"
@@ -2864,47 +3362,49 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 2868 "edn_parser.cc"
+#line 3366 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
-		case 40: goto tr4;
 		case 44: goto st3;
 		case 59: goto st4;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
-				goto tr4;
+			if ( 33 <= (*p) && (*p) <= 40 )
+				goto tr7;
 		} else if ( (*p) >= 9 )
 			goto st3;
 	} else if ( (*p) > 63 ) {
 		if ( (*p) < 94 ) {
 			if ( 65 <= (*p) && (*p) <= 92 )
-				goto tr4;
+				goto tr7;
 		} else if ( (*p) > 95 ) {
 			if ( 97 <= (*p) && (*p) <= 123 )
-				goto tr4;
+				goto tr7;
 		} else
-			goto tr4;
+			goto tr7;
 	} else
-		goto tr4;
+		goto tr7;
 	goto st0;
-tr4:
-#line 914 "edn_parser.rl"
+tr7:
+#line 965 "edn_parser.rl"
 	{
         // parses the value portion
         const char *np = parse_value(p, pe, data);
-        if (np == NULL) { p--; {p++; cs = 6; goto _out;} } else { {p = (( np))-1;} }
+        if (np == NULL) { p--; {p++; cs = 7; goto _out;} } else {
+            data_ok = true;
+            {p = (( np))-1;}
+        }
     }
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 6; goto _out;} }
-	goto st6;
-st6:
+#line 53 "edn_parser.rl"
+	{ p--; {p++; cs = 7; goto _out;} }
+	goto st7;
+st7:
 	if ( ++p == pe )
-		goto _test_eof6;
-case 6:
-#line 2908 "edn_parser.cc"
+		goto _test_eof7;
+case 7:
+#line 3408 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -2913,202 +3413,101 @@ case 4:
 	if ( (*p) == 10 )
 		goto tr3;
 	goto st4;
-tr5:
-#line 914 "edn_parser.rl"
-	{
-        // parses the value portion
-        const char *np = parse_value(p, pe, data);
-        if (np == NULL) { p--; {p++; cs = 7; goto _out;} } else { {p = (( np))-1;} }
-    }
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 7; goto _out;} }
-	goto st7;
-st7:
-	if ( ++p == pe )
-		goto _test_eof7;
-case 7:
-#line 2931 "edn_parser.cc"
-	switch( (*p) ) {
-		case 10: goto tr3;
-		case 32: goto st3;
-		case 35: goto tr5;
-		case 39: goto st2;
-		case 44: goto st3;
-		case 47: goto tr7;
-		case 59: goto st4;
-		case 94: goto tr4;
-		case 95: goto tr5;
-		case 123: goto tr4;
-	}
-	if ( (*p) < 45 ) {
-		if ( (*p) < 33 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto st3;
-		} else if ( (*p) > 40 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr4;
-		} else
-			goto tr4;
-	} else if ( (*p) > 58 ) {
-		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto tr4;
-		} else if ( (*p) > 90 ) {
-			if ( (*p) > 92 ) {
-				if ( 97 <= (*p) && (*p) <= 122 )
-					goto tr5;
-			} else if ( (*p) >= 91 )
-				goto tr4;
-		} else
-			goto tr5;
-	} else
-		goto tr5;
-	goto st0;
-tr7:
-#line 914 "edn_parser.rl"
-	{
-        // parses the value portion
-        const char *np = parse_value(p, pe, data);
-        if (np == NULL) { p--; {p++; cs = 8; goto _out;} } else { {p = (( np))-1;} }
-    }
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 8; goto _out;} }
-	goto st8;
-st8:
-	if ( ++p == pe )
-		goto _test_eof8;
-case 8:
-#line 2982 "edn_parser.cc"
-	if ( (*p) > 90 ) {
-		if ( 97 <= (*p) && (*p) <= 122 )
-			goto st5;
-	} else if ( (*p) >= 65 )
-		goto st5;
-	goto st0;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
 	switch( (*p) ) {
-		case 10: goto tr3;
-		case 32: goto st3;
-		case 35: goto tr9;
-		case 39: goto st5;
-		case 44: goto st3;
-		case 47: goto tr4;
-		case 59: goto st4;
-		case 94: goto tr4;
-		case 95: goto tr9;
-		case 123: goto tr4;
+		case 33: goto st6;
+		case 58: goto st6;
+		case 95: goto st6;
 	}
 	if ( (*p) < 45 ) {
-		if ( (*p) < 33 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto st3;
-		} else if ( (*p) > 40 ) {
+		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr4;
-		} else
-			goto tr4;
-	} else if ( (*p) > 58 ) {
+				goto st6;
+		} else if ( (*p) >= 35 )
+			goto st6;
+	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 60 <= (*p) && (*p) <= 63 )
-				goto tr4;
+				goto st6;
 		} else if ( (*p) > 90 ) {
-			if ( (*p) > 92 ) {
-				if ( 97 <= (*p) && (*p) <= 122 )
-					goto tr9;
-			} else if ( (*p) >= 91 )
-				goto tr4;
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st6;
 		} else
-			goto tr9;
+			goto st6;
 	} else
-		goto tr9;
+		goto st6;
 	goto st0;
-tr9:
-#line 914 "edn_parser.rl"
-	{
-        // parses the value portion
-        const char *np = parse_value(p, pe, data);
-        if (np == NULL) { p--; {p++; cs = 9; goto _out;} } else { {p = (( np))-1;} }
-    }
-#line 58 "edn_parser.rl"
-	{ p--; {p++; cs = 9; goto _out;} }
-	goto st9;
-st9:
+st6:
 	if ( ++p == pe )
-		goto _test_eof9;
-case 9:
-#line 3043 "edn_parser.cc"
+		goto _test_eof6;
+case 6:
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
-		case 35: goto tr9;
-		case 39: goto st5;
+		case 33: goto st6;
 		case 44: goto st3;
-		case 47: goto tr4;
 		case 59: goto st4;
-		case 94: goto tr4;
-		case 95: goto tr9;
-		case 123: goto tr4;
+		case 95: goto st6;
 	}
-	if ( (*p) < 45 ) {
-		if ( (*p) < 33 ) {
-			if ( 9 <= (*p) && (*p) <= 13 )
-				goto st3;
-		} else if ( (*p) > 40 ) {
-			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr4;
-		} else
-			goto tr4;
-	} else if ( (*p) > 58 ) {
+	if ( (*p) < 42 ) {
+		if ( (*p) > 13 ) {
+			if ( 35 <= (*p) && (*p) <= 39 )
+				goto st6;
+		} else if ( (*p) >= 9 )
+			goto st3;
+	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
-			if ( 60 <= (*p) && (*p) <= 63 )
-				goto tr4;
+			if ( 48 <= (*p) && (*p) <= 63 )
+				goto st6;
 		} else if ( (*p) > 90 ) {
-			if ( (*p) > 92 ) {
-				if ( 97 <= (*p) && (*p) <= 122 )
-					goto tr9;
-			} else if ( (*p) >= 91 )
-				goto tr4;
+			if ( 97 <= (*p) && (*p) <= 122 )
+				goto st6;
 		} else
-			goto tr9;
+			goto st6;
 	} else
-		goto tr9;
+		goto st6;
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
 	_test_eof3: cs = 3; goto _test_eof;
-	_test_eof6: cs = 6; goto _test_eof;
-	_test_eof4: cs = 4; goto _test_eof;
 	_test_eof7: cs = 7; goto _test_eof;
-	_test_eof8: cs = 8; goto _test_eof;
+	_test_eof4: cs = 4; goto _test_eof;
 	_test_eof5: cs = 5; goto _test_eof;
-	_test_eof9: cs = 9; goto _test_eof;
+	_test_eof6: cs = 6; goto _test_eof;
 
 	_test_eof: {}
 	_out: {}
 	}
 
-#line 934 "edn_parser.rl"
+#line 992 "edn_parser.rl"
 
     if (cs >= EDN_tagged_first_final) {
         //std::cerr << __FUNCTION__ << " parse symbol name as '" << sym_name << "', value is: " << data << std::endl;
 
+        if (!sym_ok || !data_ok) {
+            error(__FUNCTION__, "tagged element symbol error", *p);
+            v =  EDNT_EOF_CONST;
+            return NULL;
+        }
+
         try {
             // tagged_element makes a call to ruby which may throw an
             // exception when parsing the data
-            v = Parser::tagged_element(sym_name, data);
+            v = Parser::make_edn_type(EDNT_TAGGED_ELEM_METHOD, sym_name, data);
+            return p + 1;
         } catch (std::exception& e) {
             error(__FUNCTION__, e.what());
             return pe;
         }
-        return p + 1;
     }
     else if (cs == EDN_tagged_error) {
-        return pe;
+        error(__FUNCTION__, "tagged element symbol error", *p);
     }
     else if (cs == EDN_tagged_en_main) {} // silence ragel warning
+    v =  EDNT_EOF_CONST;
     return NULL;
 }
 
@@ -3121,7 +3520,7 @@ case 9:
 // useful?
 //
 
-#line 3125 "edn_parser.cc"
+#line 3524 "edn_parser.cc"
 static const int EDN_meta_start = 1;
 static const int EDN_meta_first_final = 3;
 static const int EDN_meta_error = 0;
@@ -3129,7 +3528,7 @@ static const int EDN_meta_error = 0;
 static const int EDN_meta_en_main = 1;
 
 
-#line 977 "edn_parser.rl"
+#line 1042 "edn_parser.rl"
 
 
 
@@ -3139,14 +3538,14 @@ const char* edn::Parser::parse_meta(const char *p, const char *pe)
     VALUE v;
 
 
-#line 3143 "edn_parser.cc"
+#line 3542 "edn_parser.cc"
 	{
 	cs = EDN_meta_start;
 	}
 
-#line 986 "edn_parser.rl"
+#line 1051 "edn_parser.rl"
 
-#line 3150 "edn_parser.cc"
+#line 3549 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3163,11 +3562,9 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-	if ( (*p) == 40 )
-		goto tr2;
 	if ( (*p) < 60 ) {
 		if ( (*p) < 42 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+			if ( 33 <= (*p) && (*p) <= 40 )
 				goto tr2;
 		} else if ( (*p) > 43 ) {
 			if ( 45 <= (*p) && (*p) <= 58 )
@@ -3187,19 +3584,19 @@ case 2:
 		goto tr2;
 	goto st0;
 tr2:
-#line 969 "edn_parser.rl"
+#line 1034 "edn_parser.rl"
 	{
         const char *np = parse_value(p, pe, v);
-        if (np) { {p = (( np))-1;} } else { p--; {p++; cs = 3; goto _out;} }
+        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else { {p = (( np))-1;} }
     }
-#line 58 "edn_parser.rl"
+#line 53 "edn_parser.rl"
 	{ p--; {p++; cs = 3; goto _out;} }
 	goto st3;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 3203 "edn_parser.cc"
+#line 3600 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -3209,10 +3606,10 @@ case 3:
 	_out: {}
 	}
 
-#line 987 "edn_parser.rl"
+#line 1052 "edn_parser.rl"
 
     if (cs >= EDN_meta_first_final) {
-        metadata.push_back(v);
+        append_to_meta(v);
         return p + 1;
     }
     else if (cs == EDN_meta_error) {
@@ -3231,7 +3628,7 @@ case 3:
 // top-level, therefore, does not tokenize source stream
 //
 
-#line 3235 "edn_parser.cc"
+#line 3632 "edn_parser.cc"
 static const int EDN_parser_start = 2;
 static const int EDN_parser_first_final = 2;
 static const int EDN_parser_error = 0;
@@ -3239,25 +3636,25 @@ static const int EDN_parser_error = 0;
 static const int EDN_parser_en_main = 2;
 
 
-#line 1036 "edn_parser.rl"
+#line 1101 "edn_parser.rl"
 
 
 
 VALUE edn::Parser::parse(const char* src, std::size_t len)
 {
     int cs;
-    VALUE result = Qnil;
+    VALUE result = EDNT_EOF_CONST;
 
 
-#line 3253 "edn_parser.cc"
+#line 3650 "edn_parser.cc"
 	{
 	cs = EDN_parser_start;
 	}
 
-#line 1045 "edn_parser.rl"
+#line 1110 "edn_parser.rl"
     set_source(src, len);
 
-#line 3261 "edn_parser.cc"
+#line 3658 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3268,20 +3665,20 @@ tr1:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 1013 "edn_parser.rl"
+#line 1078 "edn_parser.rl"
 	{
         // save the count of metadata items before we parse this value
         // so we can determine if we've read another metadata value or
         // an actual data item
-        std::size_t meta_size = metadata.size();
+        std::size_t meta_sz = meta_size();
         const char* np = parse_value(p, pe, result);
         if (np == NULL) { {p = (( pe))-1;} {p++; cs = 2; goto _out;} } else {
             // if we have metadata saved and it matches the count we
             // saved before we parsed a value, then we must bind the
             // metadata sequence to it
-            if (!metadata.empty() && metadata.size() == meta_size) {
+            if (!meta_empty() && meta_size() == meta_sz) {
                 // this will empty the metadata sequence too
-                result = bind_meta_to_value(result);
+                result = Parser::make_edn_type(EDNT_EXTENDED_VALUE_METHOD, result, ruby_meta());
             }
             {p = (( np))-1;}
         }
@@ -3291,17 +3688,16 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 3295 "edn_parser.cc"
+#line 3692 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr1;
 		case 32: goto st2;
-		case 40: goto tr4;
 		case 44: goto st2;
 		case 59: goto st1;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+			if ( 33 <= (*p) && (*p) <= 40 )
 				goto tr4;
 		} else if ( (*p) >= 9 )
 			goto st2;
@@ -3335,12 +3731,11 @@ case 1:
 	_out: {}
 	}
 
-#line 1047 "edn_parser.rl"
+#line 1112 "edn_parser.rl"
 
     if (cs == EDN_parser_error) {
-        if (p)
-            error(__FUNCTION__, *p);
-        return EDNT_EOF;
+        error(__FUNCTION__, *p);
+        return EDNT_EOF_CONST;
     }
     else if (cs == EDN_parser_first_final) {
         p = pe = eof = NULL;
@@ -3354,40 +3749,39 @@ case 1:
 // token-by-token machine
 //
 
-#line 3358 "edn_parser.cc"
+#line 3753 "edn_parser.cc"
 static const int EDN_tokens_start = 1;
-static const int EDN_tokens_error = 0;
 
 static const int EDN_tokens_en_main = 1;
 
 
-#line 1100 "edn_parser.rl"
+#line 1166 "edn_parser.rl"
 
 
 
 //
 //
-bool edn::Parser::parse_next(VALUE& value)
+edn::Parser::eTokenState edn::Parser::parse_next(VALUE& value)
 {
     int cs;
-    bool is_value = true;
+    eTokenState state = TOKEN_ERROR;
     // need to track metadada read and bind it to the next value read
     // - but must account for sequences of metadata values
-    std::size_t meta_size;
+    std::size_t meta_sz;
 
     // clear any previously saved discards; only track if read during
     // this op
     discard.clear();
 
 
-#line 3384 "edn_parser.cc"
+#line 3778 "edn_parser.cc"
 	{
 	cs = EDN_tokens_start;
 	}
 
-#line 1118 "edn_parser.rl"
+#line 1184 "edn_parser.rl"
 
-#line 3391 "edn_parser.cc"
+#line 3785 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3401,17 +3795,16 @@ st1:
 	if ( ++p == pe )
 		goto _test_eof1;
 case 1:
-#line 3405 "edn_parser.cc"
+#line 3799 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr2;
 		case 32: goto st1;
-		case 40: goto tr3;
 		case 44: goto st1;
 		case 59: goto st3;
 	}
 	if ( (*p) < 42 ) {
 		if ( (*p) > 13 ) {
-			if ( 33 <= (*p) && (*p) <= 38 )
+			if ( 33 <= (*p) && (*p) <= 40 )
 				goto tr3;
 		} else if ( (*p) >= 9 )
 			goto st1;
@@ -3435,31 +3828,33 @@ tr6:
 	{ line_number++; }
 	goto st4;
 tr3:
-#line 1070 "edn_parser.rl"
+#line 1134 "edn_parser.rl"
 	{
         // we won't know if we've parsed a discard or a metadata until
         // after parse_value() is done. Save the current number of
         // elements in the metadata sequence; then we can check if it
         // grew or if the discard sequence grew
-        meta_size = metadata.size();
+        meta_sz = meta_size();
 
         const char* np = parse_value(p, pe, value);
-
         if (np == NULL) { p--; {p++; cs = 4; goto _out;} } else {
-            if (metadata.size() > 0) {
-                // was anotheran additional metadata entry read? if
-                // so, don't return a value
-                if (metadata.size() > meta_size) {
-                    is_value = false;
+            if (!meta_empty()) {
+                // was an additional metadata entry read? if so, don't
+                // return a value
+                if (meta_size() > meta_sz) {
+                    state = TOKEN_IS_META;
                 }
                 else {
                     // a value was read and there's a pending metadata
                     // sequence. Bind them.
-                    value = bind_meta_to_value(value);
+                    value = Parser::make_edn_type(EDNT_EXTENDED_VALUE_METHOD, value, ruby_meta());
+                    state = TOKEN_OK;
                 }
             } else if (!discard.empty()) {
                 // a discard read. Don't return a value
-                is_value = false;
+                state = TOKEN_IS_DISCARD;
+            } else {
+                state = TOKEN_OK;
             }
             {p = (( np))-1;}
         }
@@ -3469,7 +3864,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 3473 "edn_parser.cc"
+#line 3868 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr6;
 		case 32: goto st4;
@@ -3503,14 +3898,10 @@ case 3:
 	_out: {}
 	}
 
-#line 1119 "edn_parser.rl"
-
-    if (cs == EDN_parser_error) {
-        value = EDNT_EOF;
-    }
-    else if (cs == EDN_tokens_en_main) {} // silence ragel warning
+#line 1185 "edn_parser.rl"
 
-    return is_value;
+    if (cs == EDN_tokens_en_main) {} // silence ragel warning
+    return state;
 }