edn_turbo 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 409d493aab7167c3bac13a53580bea45735c02fc1918f57fd5b386a390d43750
-  data.tar.gz: 3c9b3786db7a9b2f7732735898b3b78c7dfab041b3f11511d8866b7093629cf5
+  metadata.gz: 695a3c68e9f69b9423a4da07056dfd8f264f62b39896c938938e56d1e28c395f
+  data.tar.gz: a370c5b31f462288fd340771c901d47f27e45e2308ef98728cb6abe59596631a
 SHA512:
-  metadata.gz: a1b753f68eadd7e5466dd863606085dd8eeaa489c01e0ef5473ccb9e5562d70611ff35999db5263ffef42813a1404f118f26672482b36e7ca2e8fde50e96d187
-  data.tar.gz: d0ab9b94babb9c4d0293f270266963555e805edbaf09a28c55de59281fba52e6fb6cb0af189eecd4daa96029d254d5521d1fa916d3f91ff9e2c638b4cbc7c08b
+  metadata.gz: 9b9b5aeb7c5b62d4add2ff2faa190138cf1baf0e902bdf3a28468c382ef0e94f6c95f93e3e05c48d7deb31e708d92f41607da60183b510593aa741eb68817be5
+  data.tar.gz: 39fb3b6b18cf3593fd537843aa2a08089552cb8900691ca88e3d8a86d05706e5f5ef557c8f3521c0b68b812652d1770f5f3a4621ca30087fa06299266a330352

data/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Change Log
 All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
 
+## 0.6.1 - 2019-05-20
+### Added
+- Implement parsing of Ratio literals, represented as a ruby Rational.
+
+### Fixed
+- Parsing of exact precision types.
+
+### Changed
+- Build lists using EDN::list method that was previously broken.
+
+
 ## 0.6.0 - 2019-05-13
 ### Changed
 - switched from MiniTest to RSpec.

data/README.md

@@ -1,7 +1,7 @@
-edn_turbo 0.6.0
+edn_turbo 0.6.1
 ===============
 
-Fast (Ragel)[http://www.colm.net/open-source/ragel/]-based EDN parser for Ruby.
+Fast [Ragel](http://www.colm.net/open-source/ragel/)-based EDN parser for Ruby.
 
 `edn_turbo` can be used as a parser plugin for
 [edn](https://github.com/relevance/edn-ruby). With a few exceptions
@@ -66,10 +66,10 @@ the API is the same as the edn gem.
     # also accepts a string
     pp EDN.read("[ 1 2 3 abc ]")
 
-	# metadata
-	e = EDN.read('^String ^:foo ^{:foo false :tag Boolean :bar 2} [1 2]')
-	pp e          # -> [1, 2]
-	pp e.metadata # -> {:foo=>true, :tag=>#<EDN::Type::Symbol:0x007fdbea8a29b0 @symbol=:String>, :bar=>2}
+    # metadata
+    e = EDN.read('^String ^:foo ^{:foo false :tag Boolean :bar 2} [1 2]')
+    pp e          # -> [1, 2]
+    pp e.metadata # -> {:foo=>true, :tag=>#<EDN::Type::Symbol:0x007fdbea8a29b0 @symbol=:String>, :bar=>2}
 
 ```
 

data/bin/build_docker_image.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-if [[ $# -ne 1 ]]; then
+if [[ $# -eq 0 ]]; then
     RUBY_VERSION=2.6.3
 else
     RUBY_VERSION=$1

data/ext/edn_turbo/edn_parser.cc

@@ -59,14 +59,14 @@ static const int EDN_value_error = 0;
 static const int EDN_value_en_main = 1;
 
 
-#line 197 "edn_parser.rl"
+#line 202 "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;
+   //    std::cerr << __FUNCTION__ << "() p: \"" << p << "\"" << std::endl;
+   int cs;
 
 
 #line 73 "edn_parser.cc"
@@ -74,7 +74,7 @@ const char *edn::Parser::parse_value(const char *p, const char *pe, VALUE& v)
 	cs = EDN_value_start;
 	}
 
-#line 206 "edn_parser.rl"
+#line 211 "edn_parser.rl"
 
 #line 80 "edn_parser.cc"
 	{
@@ -119,116 +119,121 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 125 "edn_parser.rl"
+#line 130 "edn_parser.rl"
 	{
-        // stand-alone operators *, +, -, etc.
-        const char *np = parse_operator(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // stand-alone operators *, +, -, etc.
+      const char *np = parse_operator(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr2:
 #line 93 "edn_parser.rl"
 	{
-        // string types within double-quotes
-        const char *np = parse_string(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // string types within double-quotes
+      const char *np = parse_string(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr3:
-#line 177 "edn_parser.rl"
+#line 182 "edn_parser.rl"
 	{
-        // handles tokens w/ leading # ("#_", "#{", and tagged elems)
-        const char *np = parse_dispatch(p + 1, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // handles tokens w/ leading # ("#_", "#{", and tagged elems)
+      const char *np = parse_dispatch(p + 1, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr4:
-#line 159 "edn_parser.rl"
+#line 164 "edn_parser.rl"
 	{
-        // (
-        const char *np = parse_list(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // (
+      const char *np = parse_list(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr5:
 #line 105 "edn_parser.rl"
 	{
-        // tokens w/ leading digits: non-negative integers & decimals.
-        // try to parse a decimal first
-        const char *np = parse_decimal(p, pe, v);
-        if (np == nullptr) {
-            // if we can't, try to parse it as an int
+      // tokens w/ leading digits: non-negative integers & decimals.
+      // try to parse a decimal first
+      const char *np = parse_decimal(p, pe, v);
+      if (np == nullptr) {
+         // if we can't, try to parse it as a ratio
+         np = parse_ratio(p, pe, v);
+
+         // otherwise, an int
+         if (np == nullptr) {
             np = parse_integer(p, pe, v);
-        }
-
-        if (np) {
-            {p = (( np))-1;}
-            p--;
-            {p++; cs = 2; goto _out;}
-        }
-        else {
-            error(__FUNCTION__, "number format error", *p);
-            {p = (( pe))-1;}
-        }
-    }
+         }
+      }
+
+      if (np) {
+         {p = (( np))-1;}
+         p--;
+         {p++; cs = 2; goto _out;}
+      }
+      else {
+         error(__FUNCTION__, "number format error", *p);
+         {p = (( pe))-1;}
+      }
+   }
 	goto st2;
 tr6:
 #line 99 "edn_parser.rl"
 	{
-        // tokens with a leading ':'
-        const char *np = parse_keyword(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // tokens with a leading ':'
+      const char *np = parse_keyword(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr7:
-#line 137 "edn_parser.rl"
-	{
-        // user identifiers and reserved keywords (true, false, nil)
-        VALUE sym = Qnil;
-        const char *np = parse_symbol(p, pe, sym);
-        if (np == nullptr) { {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 = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            }
-            {p = (( np))-1;}
-        }
-    }
+#line 142 "edn_parser.rl"
+	{
+      // user identifiers and reserved keywords (true, false, nil)
+      VALUE sym = Qnil;
+      const char *np = parse_symbol(p, pe, sym);
+      if (np == nullptr) { {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 = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st2;
 tr8:
-#line 153 "edn_parser.rl"
+#line 158 "edn_parser.rl"
 	{
-        // [
-        const char *np = parse_vector(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // [
+      const char *np = parse_vector(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr9:
-#line 131 "edn_parser.rl"
+#line 136 "edn_parser.rl"
 	{
-        // tokens w/ leading \ (escaped characters \newline, \c, etc.)
-        const char *np = parse_esc_char(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // tokens w/ leading \ (escaped characters \newline, \c, etc.)
+      const char *np = parse_esc_char(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr10:
-#line 171 "edn_parser.rl"
+#line 176 "edn_parser.rl"
 	{
-        // ^
-        const char *np = parse_meta(p, pe);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // ^
+      const char *np = parse_meta(p, pe);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 tr11:
-#line 165 "edn_parser.rl"
+#line 170 "edn_parser.rl"
 	{
-        // {
-        const char *np = parse_map(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // {
+      const char *np = parse_map(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
@@ -236,7 +241,7 @@ st2:
 case 2:
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
-#line 240 "edn_parser.cc"
+#line 245 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -245,17 +250,17 @@ case 2:
 	_out: {}
 	}
 
-#line 207 "edn_parser.rl"
+#line 212 "edn_parser.rl"
 
-    if (cs >= EDN_value_first_final) {
-        return p;
-    }
-    else if (cs == EDN_value_error) {
-        error(__FUNCTION__, "token error", *p);
-        return pe;
-    }
-    else if (cs == EDN_value_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_value_first_final) {
+      return p;
+   }
+   else if (cs == EDN_value_error) {
+      error(__FUNCTION__, "token error", *p);
+      return pe;
+   }
+   else if (cs == EDN_value_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -267,7 +272,7 @@ case 2:
 // ascii range is found.
 //
 
-#line 271 "edn_parser.cc"
+#line 276 "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;
@@ -275,26 +280,26 @@ static const int EDN_string_error = 0;
 static const int EDN_string_en_main = 1;
 
 
-#line 252 "edn_parser.rl"
+#line 257 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_string(const char *p, const char *pe, VALUE& v)
 {
-    static const char* EDN_TYPE = "string";
-    int cs;
-    bool encode = false;
+   static const char* EDN_TYPE = "string";
+   int cs;
+   bool encode = false;
 
 
-#line 290 "edn_parser.cc"
+#line 295 "edn_parser.cc"
 	{
 	cs = EDN_string_start;
 	}
 
-#line 262 "edn_parser.rl"
-    const char* p_save = p;
+#line 267 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 298 "edn_parser.cc"
+#line 303 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -308,16 +313,16 @@ st0:
 cs = 0;
 	goto _out;
 tr2:
-#line 241 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 321 "edn_parser.cc"
+#line 326 "edn_parser.cc"
 	switch( (*p) ) {
 		case 34: goto tr3;
 		case 92: goto tr4;
@@ -326,14 +331,14 @@ case 2:
 		goto tr2;
 	goto st2;
 tr3:
-#line 233 "edn_parser.rl"
-	{
-        if (edn::util::parse_byte_stream(p_save + 1, p, v, encode)) {
-            {p = (( p + 1))-1;}
-        } else {
-            p--; {p++; cs = 8; goto _out;}
-        }
-    }
+#line 238 "edn_parser.rl"
+	{
+      if (edn::util::parse_byte_stream(p_save + 1, p, v, encode)) {
+         {p = (( p + 1))-1;}
+      } else {
+         p--; {p++; cs = 8; goto _out;}
+      }
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 8; goto _out;} }
 	goto st8;
@@ -341,19 +346,19 @@ st8:
 	if ( ++p == pe )
 		goto _test_eof8;
 case 8:
-#line 345 "edn_parser.cc"
+#line 350 "edn_parser.cc"
 	goto st0;
 tr4:
-#line 241 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st3;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 357 "edn_parser.cc"
+#line 362 "edn_parser.cc"
 	switch( (*p) ) {
 		case 34: goto tr2;
 		case 47: goto tr2;
@@ -367,16 +372,16 @@ case 3:
 	}
 	goto st2;
 tr5:
-#line 241 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 380 "edn_parser.cc"
+#line 385 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr6;
@@ -387,16 +392,16 @@ case 4:
 		goto tr6;
 	goto st0;
 tr6:
-#line 241 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 400 "edn_parser.cc"
+#line 405 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr7;
@@ -407,16 +412,16 @@ case 5:
 		goto tr7;
 	goto st0;
 tr7:
-#line 241 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 420 "edn_parser.cc"
+#line 425 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr8;
@@ -427,16 +432,16 @@ case 6:
 		goto tr8;
 	goto st0;
 tr8:
-#line 241 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st7;
 st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 440 "edn_parser.cc"
+#line 445 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr2;
@@ -462,29 +467,29 @@ case 7:
 	case 2:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	break;
-#line 472 "edn_parser.cc"
+#line 477 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 264 "edn_parser.rl"
+#line 269 "edn_parser.rl"
 
-    if (cs >= EDN_string_first_final) {
-        return p + 1;
-    }
-    else if (cs == EDN_string_error) {
-        return pe;
-    }
-    else if (cs == EDN_string_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_string_first_final) {
+      return p + 1;
+   }
+   else if (cs == EDN_string_error) {
+      return pe;
+   }
+   else if (cs == EDN_string_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -493,7 +498,7 @@ case 7:
 // keyword parsing
 //
 
-#line 497 "edn_parser.cc"
+#line 502 "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;
@@ -501,24 +506,24 @@ static const int EDN_keyword_error = 0;
 static const int EDN_keyword_en_main = 1;
 
 
-#line 294 "edn_parser.rl"
+#line 299 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_keyword(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 514 "edn_parser.cc"
+#line 519 "edn_parser.cc"
 	{
 	cs = EDN_keyword_start;
 	}
 
-#line 302 "edn_parser.rl"
-    const char* p_save = p;
+#line 307 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 522 "edn_parser.cc"
+#line 527 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -592,7 +597,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 596 "edn_parser.cc"
+#line 601 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -631,55 +636,54 @@ case 5:
 	_out: {}
 	}
 
-#line 304 "edn_parser.rl"
-
-    if (cs >= EDN_keyword_first_final) {
-        std::string buf;
-        uintmax_t len = p - p_save;
-        // don't include leading ':' because the ruby symbol will handle it
-        buf.append(p_save + 1, len - 1);
-        v = ID2SYM(rb_intern(buf.c_str()));
-        return p;
-    }
-    else if (cs == EDN_keyword_error) {
-        error(__FUNCTION__, "invalid keyword", *p);
-        return pe;
-    }
-    else if (cs == EDN_keyword_en_main) {} // silence ragel warning
-    return nullptr;
+#line 309 "edn_parser.rl"
+
+   if (cs >= EDN_keyword_first_final) {
+      std::string buf;
+      uintmax_t len = p - p_save;
+      // don't include leading ':' because the ruby symbol will handle it
+      buf.append(p_save + 1, len - 1);
+      v = ID2SYM(rb_intern(buf.c_str()));
+      return p;
+   }
+   else if (cs == EDN_keyword_error) {
+      error(__FUNCTION__, "invalid keyword", *p);
+      return pe;
+   }
+   else if (cs == EDN_keyword_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
-
 // ============================================================
 // decimal parsing machine
 //
 
-#line 659 "edn_parser.cc"
+#line 663 "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 337 "edn_parser.rl"
+#line 341 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_decimal(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 675 "edn_parser.cc"
+#line 679 "edn_parser.cc"
 	{
 	cs = EDN_decimal_start;
 	}
 
-#line 345 "edn_parser.rl"
-    const char* p_save = p;
+#line 349 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 683 "edn_parser.cc"
+#line 687 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -740,7 +744,7 @@ st10:
 	if ( ++p == pe )
 		goto _test_eof10;
 case 10:
-#line 744 "edn_parser.cc"
+#line 748 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -856,14 +860,14 @@ case 8:
 	_out: {}
 	}
 
-#line 347 "edn_parser.rl"
+#line 351 "edn_parser.rl"
 
-    if (cs >= EDN_decimal_first_final) {
-        v = edn::util::float_to_ruby(p_save, p - p_save);
-        return p + 1;
-    }
-    else if (cs == EDN_decimal_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_decimal_first_final) {
+      v = edn::util::float_to_ruby(p_save, p - p_save);
+      return p + 1;
+   }
+   else if (cs == EDN_decimal_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -871,30 +875,30 @@ case 8:
 // integer parsing machine - M suffix will return a BigNum
 //
 
-#line 875 "edn_parser.cc"
+#line 879 "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 370 "edn_parser.rl"
+#line 374 "edn_parser.rl"
 
 
 const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 890 "edn_parser.cc"
+#line 894 "edn_parser.cc"
 	{
 	cs = EDN_integer_start;
 	}
 
-#line 377 "edn_parser.rl"
-    const char* p_save = p;
+#line 381 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 898 "edn_parser.cc"
+#line 902 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -943,7 +947,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 947 "edn_parser.cc"
+#line 951 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -984,17 +988,152 @@ case 6:
 	_out: {}
 	}
 
-#line 379 "edn_parser.rl"
+#line 383 "edn_parser.rl"
 
-    if (cs >= EDN_integer_first_final) {
-        v = edn::util::integer_to_ruby(p_save, p - p_save);
-        return p + 1;
-    }
-    else if (cs == EDN_integer_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_integer_first_final) {
+      v = edn::util::integer_to_ruby(p_save, p - p_save);
+      return p + 1;
+   }
+   else if (cs == EDN_integer_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
+// ============================================================
+// ratio parsing machine
+//
+
+#line 1007 "edn_parser.cc"
+static const int EDN_ratio_start = 1;
+static const int EDN_ratio_first_final = 6;
+
+static const int EDN_ratio_en_main = 1;
+
+
+#line 406 "edn_parser.rl"
+
+
+
+const char* edn::Parser::parse_ratio(const char *p, const char *pe, VALUE& v)
+{
+   int cs;
+
+
+#line 1023 "edn_parser.cc"
+	{
+	cs = EDN_ratio_start;
+	}
+
+#line 414 "edn_parser.rl"
+   const char* p_save = p;
+
+#line 1031 "edn_parser.cc"
+	{
+	if ( p == pe )
+		goto _test_eof;
+	switch ( cs )
+	{
+case 1:
+	switch( (*p) ) {
+		case 43: goto st2;
+		case 45: goto st2;
+		case 48: goto st3;
+	}
+	if ( 49 <= (*p) && (*p) <= 57 )
+		goto st5;
+	goto st0;
+st0:
+cs = 0;
+	goto _out;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+	if ( (*p) == 48 )
+		goto st3;
+	if ( 49 <= (*p) && (*p) <= 57 )
+		goto st5;
+	goto st0;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+	if ( (*p) == 47 )
+		goto st4;
+	goto st0;
+st4:
+	if ( ++p == pe )
+		goto _test_eof4;
+case 4:
+	if ( (*p) == 48 )
+		goto st6;
+	if ( 49 <= (*p) && (*p) <= 57 )
+		goto st8;
+	goto st0;
+st6:
+	if ( ++p == pe )
+		goto _test_eof6;
+case 6:
+	switch( (*p) ) {
+		case 43: goto st0;
+		case 45: goto st0;
+	}
+	if ( 47 <= (*p) && (*p) <= 57 )
+		goto st0;
+	goto tr7;
+tr7:
+#line 80 "edn_parser.rl"
+	{ p--; {p++; cs = 7; goto _out;} }
+	goto st7;
+st7:
+	if ( ++p == pe )
+		goto _test_eof7;
+case 7:
+#line 1093 "edn_parser.cc"
+	goto st0;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+	switch( (*p) ) {
+		case 43: goto st0;
+		case 45: goto st0;
+		case 47: goto st0;
+	}
+	if ( 48 <= (*p) && (*p) <= 57 )
+		goto st8;
+	goto tr7;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+	if ( (*p) == 47 )
+		goto st4;
+	if ( 48 <= (*p) && (*p) <= 57 )
+		goto st5;
+	goto st0;
+	}
+	_test_eof2: cs = 2; goto _test_eof;
+	_test_eof3: cs = 3; goto _test_eof;
+	_test_eof4: cs = 4; 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_eof5: cs = 5; goto _test_eof;
+
+	_test_eof: {}
+	_out: {}
+	}
+
+#line 416 "edn_parser.rl"
+
+   if (cs >= EDN_ratio_first_final) {
+      v = edn::util::ratio_to_ruby(p_save, p - p_save);
+      return p + 1;
+   }
+   else if (cs == EDN_ratio_en_main) {} // silence ragel warning
+   return nullptr;
+}
 
 // ============================================================
 // operator parsing - handles tokens w/ a leading operator:
@@ -1004,7 +1143,7 @@ case 6:
 // 3. stand-alone operators: +, -, /, *, etc.
 //
 
-#line 1008 "edn_parser.cc"
+#line 1147 "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;
@@ -1012,24 +1151,24 @@ static const int EDN_operator_error = 0;
 static const int EDN_operator_en_main = 1;
 
 
-#line 453 "edn_parser.rl"
+#line 493 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_operator(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 1025 "edn_parser.cc"
+#line 1164 "edn_parser.cc"
 	{
 	cs = EDN_operator_start;
 	}
 
-#line 461 "edn_parser.rl"
-    const char* p_save = p;
+#line 501 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 1033 "edn_parser.cc"
+#line 1172 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1082,13 +1221,13 @@ case 3:
 		goto tr9;
 	goto tr6;
 tr6:
-#line 437 "edn_parser.rl"
+#line 477 "edn_parser.rl"
 	{
-        // stand-alone operators (-, +, /, ... etc)
-        char op[2] = { *p_save, 0 };
-        VALUE sym = rb_str_new2(op);
-        v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-    }
+      // stand-alone operators (-, +, /, ... etc)
+      char op[2] = { *p_save, 0 };
+      VALUE sym = rb_str_new2(op);
+      v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -1097,17 +1236,17 @@ tr11:
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 tr17:
-#line 403 "edn_parser.rl"
-	{
-        // parse a symbol including the leading operator (-, +, .)
-        VALUE sym = Qnil;
-        const char *np = parse_symbol(p_save, pe, sym);
-        if (np == nullptr) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+#line 438 "edn_parser.rl"
+	{
+      // parse a symbol including the leading operator (-, +, .)
+      VALUE sym = Qnil;
+      const char *np = parse_symbol(p_save, pe, sym);
+      if (np == nullptr) { {p = (( pe))-1;} } else {
+         if (sym != Qnil)
+            v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+         {p = (( np))-1;}
+      }
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -1115,31 +1254,31 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1119 "edn_parser.cc"
+#line 1258 "edn_parser.cc"
 	goto st0;
 tr5:
 #line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st5;
 tr7:
-#line 437 "edn_parser.rl"
+#line 477 "edn_parser.rl"
 	{
-        // stand-alone operators (-, +, /, ... etc)
-        char op[2] = { *p_save, 0 };
-        VALUE sym = rb_str_new2(op);
-        v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-    }
+      // stand-alone operators (-, +, /, ... etc)
+      char op[2] = { *p_save, 0 };
+      VALUE sym = rb_str_new2(op);
+      v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 tr8:
-#line 437 "edn_parser.rl"
+#line 477 "edn_parser.rl"
 	{
-        // stand-alone operators (-, +, /, ... etc)
-        char op[2] = { *p_save, 0 };
-        VALUE sym = rb_str_new2(op);
-        v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-    }
+      // stand-alone operators (-, +, /, ... etc)
+      char op[2] = { *p_save, 0 };
+      VALUE sym = rb_str_new2(op);
+      v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+   }
 #line 47 "edn_parser.rl"
 	{ line_number++; }
 #line 80 "edn_parser.rl"
@@ -1159,7 +1298,7 @@ st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 1163 "edn_parser.cc"
+#line 1302 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr13;
 		case 32: goto tr12;
@@ -1184,13 +1323,13 @@ case 5:
 		goto st0;
 	goto tr11;
 tr10:
-#line 437 "edn_parser.rl"
+#line 477 "edn_parser.rl"
 	{
-        // stand-alone operators (-, +, /, ... etc)
-        char op[2] = { *p_save, 0 };
-        VALUE sym = rb_str_new2(op);
-        v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-    }
+      // stand-alone operators (-, +, /, ... etc)
+      char op[2] = { *p_save, 0 };
+      VALUE sym = rb_str_new2(op);
+      v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
@@ -1202,7 +1341,7 @@ st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 1206 "edn_parser.cc"
+#line 1345 "edn_parser.cc"
 	if ( (*p) == 10 )
 		goto tr5;
 	goto st2;
@@ -1214,48 +1353,53 @@ case 2:
 		goto tr5;
 	goto st2;
 tr9:
-#line 403 "edn_parser.rl"
-	{
-        // parse a symbol including the leading operator (-, +, .)
-        VALUE sym = Qnil;
-        const char *np = parse_symbol(p_save, pe, sym);
-        if (np == nullptr) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+#line 438 "edn_parser.rl"
+	{
+      // parse a symbol including the leading operator (-, +, .)
+      VALUE sym = Qnil;
+      const char *np = parse_symbol(p_save, pe, sym);
+      if (np == nullptr) { {p = (( pe))-1;} } else {
+         if (sym != Qnil)
+            v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+         {p = (( np))-1;}
+      }
+   }
 	goto st7;
 tr16:
-#line 414 "edn_parser.rl"
-	{
-        // parse a number with the leading symbol - this is slightly
-        // different than the one within EDN_value since it includes
-        // the leading - or +
-        //
-        // try to parse a decimal first
-        const char *np = parse_decimal(p_save, pe, v);
-        if (np == nullptr) {
-            // if we can't, try to parse it as an int
+#line 449 "edn_parser.rl"
+	{
+      // parse a number with the leading symbol - this is slightly
+      // different than the one within EDN_value since it includes
+      // the leading - or +
+      //
+      // try to parse a decimal first
+      const char *np = parse_decimal(p_save, pe, v);
+      if (np == nullptr) {
+         // if we can't, try to parse it as a ratio
+         np = parse_ratio(p_save, pe, v);
+
+         if (np == nullptr) {
+            // again, if we can't, try to parse it as an int
             np = parse_integer(p_save, pe, v);
-        }
-
-        if (np) {
-            {p = (( np))-1;}
-            p--;
-            {p++; cs = 7; goto _out;}
-        }
-        else {
-            error(__FUNCTION__, "number format error", *p);
-            {p = (( pe))-1;}
-        }
-    }
+         }
+      }
+
+      if (np) {
+         {p = (( np))-1;}
+         p--;
+         {p++; cs = 7; goto _out;}
+      }
+      else {
+         error(__FUNCTION__, "number format error", *p);
+         {p = (( pe))-1;}
+      }
+   }
 	goto st7;
 st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 1259 "edn_parser.cc"
+#line 1403 "edn_parser.cc"
 	switch( (*p) ) {
 		case 33: goto st0;
 		case 95: goto st0;
@@ -1338,23 +1482,23 @@ case 9:
 		goto tr18;
 	goto tr17;
 tr18:
-#line 403 "edn_parser.rl"
-	{
-        // parse a symbol including the leading operator (-, +, .)
-        VALUE sym = Qnil;
-        const char *np = parse_symbol(p_save, pe, sym);
-        if (np == nullptr) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+#line 438 "edn_parser.rl"
+	{
+      // parse a symbol including the leading operator (-, +, .)
+      VALUE sym = Qnil;
+      const char *np = parse_symbol(p_save, pe, sym);
+      if (np == nullptr) { {p = (( pe))-1;} } else {
+         if (sym != Qnil)
+            v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+         {p = (( np))-1;}
+      }
+   }
 	goto st10;
 st10:
 	if ( ++p == pe )
 		goto _test_eof10;
 case 10:
-#line 1358 "edn_parser.cc"
+#line 1502 "edn_parser.cc"
 	switch( (*p) ) {
 		case 33: goto st10;
 		case 95: goto st10;
@@ -1427,47 +1571,47 @@ case 11:
 	{
 	switch ( cs ) {
 	case 9:
-#line 403 "edn_parser.rl"
-	{
-        // parse a symbol including the leading operator (-, +, .)
-        VALUE sym = Qnil;
-        const char *np = parse_symbol(p_save, pe, sym);
-        if (np == nullptr) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+#line 438 "edn_parser.rl"
+	{
+      // parse a symbol including the leading operator (-, +, .)
+      VALUE sym = Qnil;
+      const char *np = parse_symbol(p_save, pe, sym);
+      if (np == nullptr) { {p = (( pe))-1;} } else {
+         if (sym != Qnil)
+            v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+         {p = (( np))-1;}
+      }
+   }
 	break;
 	case 3:
 	case 8:
 	case 11:
-#line 437 "edn_parser.rl"
+#line 477 "edn_parser.rl"
 	{
-        // stand-alone operators (-, +, /, ... etc)
-        char op[2] = { *p_save, 0 };
-        VALUE sym = rb_str_new2(op);
-        v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-    }
+      // stand-alone operators (-, +, /, ... etc)
+      char op[2] = { *p_save, 0 };
+      VALUE sym = rb_str_new2(op);
+      v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+   }
 	break;
-#line 1454 "edn_parser.cc"
+#line 1598 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 463 "edn_parser.rl"
+#line 503 "edn_parser.rl"
 
-    if (cs >= EDN_operator_first_final) {
-        return p;
-    }
-    else if (cs == EDN_operator_error) {
-        error(__FUNCTION__, "symbol syntax error", *p);
-        return pe;
-    }
-    else if (cs == EDN_operator_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_operator_first_final) {
+      return p;
+   }
+   else if (cs == EDN_operator_error) {
+      error(__FUNCTION__, "symbol syntax error", *p);
+      return pe;
+   }
+   else if (cs == EDN_operator_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -1476,7 +1620,7 @@ case 11:
 // escaped char parsing - handles \c, \newline, \formfeed, etc.
 //
 
-#line 1480 "edn_parser.cc"
+#line 1624 "edn_parser.cc"
 static const int EDN_escaped_char_start = 1;
 static const int EDN_escaped_char_first_final = 26;
 static const int EDN_escaped_char_error = 0;
@@ -1484,24 +1628,24 @@ static const int EDN_escaped_char_error = 0;
 static const int EDN_escaped_char_en_main = 1;
 
 
-#line 493 "edn_parser.rl"
+#line 533 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_esc_char(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 1497 "edn_parser.cc"
+#line 1641 "edn_parser.cc"
 	{
 	cs = EDN_escaped_char_start;
 	}
 
-#line 501 "edn_parser.rl"
-    const char* p_save = p;
+#line 541 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 1505 "edn_parser.cc"
+#line 1649 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1559,7 +1703,7 @@ st27:
 	if ( ++p == pe )
 		goto _test_eof27;
 case 27:
-#line 1563 "edn_parser.cc"
+#line 1707 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr10;
 		case 32: goto tr28;
@@ -1584,7 +1728,7 @@ st28:
 	if ( ++p == pe )
 		goto _test_eof28;
 case 28:
-#line 1588 "edn_parser.cc"
+#line 1732 "edn_parser.cc"
 	goto st0;
 st29:
 	if ( ++p == pe )
@@ -1893,26 +2037,25 @@ case 25:
 	_out: {}
 	}
 
-#line 503 "edn_parser.rl"
-
-    if (cs >= EDN_escaped_char_first_final) {
-        // convert the escaped value to a character
-        if (!edn::util::parse_escaped_char(p_save + 1, p, v)) {
-            return pe;
-        }
-        return p;
-    }
-    else if (cs == EDN_escaped_char_error) {
-        error(__FUNCTION__, "unexpected value", *p);
-        return pe;
-    }
-    else if (cs == EDN_escaped_char_en_main) {} // silence ragel warning
-    return nullptr;
+#line 543 "edn_parser.rl"
+
+   if (cs >= EDN_escaped_char_first_final) {
+      // convert the escaped value to a character
+      if (!edn::util::parse_escaped_char(p_save + 1, p, v)) {
+         return pe;
+      }
+      return p;
+   }
+   else if (cs == EDN_escaped_char_error) {
+      error(__FUNCTION__, "unexpected value", *p);
+      return pe;
+   }
+   else if (cs == EDN_escaped_char_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
 
-
 // ============================================================
 // symbol parsing - handles identifiers that begin with an alpha
 // character and an optional leading operator (name, -today,
@@ -1920,7 +2063,7 @@ case 25:
 //
 //
 
-#line 1924 "edn_parser.cc"
+#line 2067 "edn_parser.cc"
 static const int EDN_symbol_start = 1;
 static const int EDN_symbol_first_final = 4;
 static const int EDN_symbol_error = 0;
@@ -1928,24 +2071,24 @@ static const int EDN_symbol_error = 0;
 static const int EDN_symbol_en_main = 1;
 
 
-#line 554 "edn_parser.rl"
+#line 593 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_symbol(const char *p, const char *pe, VALUE& s)
 {
-    int cs;
+   int cs;
 
 
-#line 1941 "edn_parser.cc"
+#line 2084 "edn_parser.cc"
 	{
 	cs = EDN_symbol_start;
 	}
 
-#line 562 "edn_parser.rl"
-    const char* p_save = p;
+#line 601 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 1949 "edn_parser.cc"
+#line 2092 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2014,7 +2157,7 @@ st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 2018 "edn_parser.cc"
+#line 2161 "edn_parser.cc"
 	goto st0;
 tr4:
 #line 47 "edn_parser.rl"
@@ -2034,7 +2177,7 @@ st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 2038 "edn_parser.cc"
+#line 2181 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr9;
 		case 32: goto tr8;
@@ -2066,7 +2209,7 @@ st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 2070 "edn_parser.cc"
+#line 2213 "edn_parser.cc"
 	if ( (*p) == 10 )
 		goto tr4;
 	goto st2;
@@ -2174,24 +2317,23 @@ case 9:
 	_out: {}
 	}
 
-#line 564 "edn_parser.rl"
-
-    if (cs >= EDN_symbol_first_final) {
-        // copy the symbol text
-        if (s == Qnil)
-            s = rb_str_new2("");
-        rb_str_cat(s, p_save, p - p_save);
-        return p;
-    }
-    else if (cs == EDN_symbol_error) {
-        error(__FUNCTION__, "invalid symbol sequence", *p);
-    }
-    else if (cs == EDN_symbol_en_main) {} // silence ragel warning
-    return nullptr;
+#line 603 "edn_parser.rl"
+
+   if (cs >= EDN_symbol_first_final) {
+      // copy the symbol text
+      if (s == Qnil)
+         s = rb_str_new2("");
+      rb_str_cat(s, p_save, p - p_save);
+      return p;
+   }
+   else if (cs == EDN_symbol_error) {
+      error(__FUNCTION__, "invalid symbol sequence", *p);
+   }
+   else if (cs == EDN_symbol_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
-
 // ============================================================
 // EDN_sequence_common is used to parse EDN containers - elements are
 // initially stored in an array and then the final corresponding
@@ -2199,13 +2341,13 @@ case 9:
 // sets the same array is used)
 //
 
-#line 642 "edn_parser.rl"
+#line 680 "edn_parser.rl"
 
 
 //
 // vector-specific machine
 
-#line 2209 "edn_parser.cc"
+#line 2351 "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;
@@ -2213,7 +2355,7 @@ static const int EDN_vector_error = 0;
 static const int EDN_vector_en_main = 1;
 
 
-#line 657 "edn_parser.rl"
+#line 695 "edn_parser.rl"
 
 
 
@@ -2222,20 +2364,20 @@ static const int EDN_vector_en_main = 1;
 //
 const char* edn::Parser::parse_vector(const char *p, const char *pe, VALUE& v)
 {
-    static const char* EDN_TYPE = "vector";
+   static const char* EDN_TYPE = "vector";
 
-    int cs;
-    VALUE elems; // will store the vector's elements - allocated in @open_seq
+   int cs;
+   VALUE elems; // will store the vector's elements - allocated in @open_seq
 
 
-#line 2232 "edn_parser.cc"
+#line 2374 "edn_parser.cc"
 	{
 	cs = EDN_vector_start;
 	}
 
-#line 671 "edn_parser.rl"
+#line 709 "edn_parser.rl"
 
-#line 2239 "edn_parser.cc"
+#line 2381 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2248,72 +2390,72 @@ case 1:
 tr2:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	goto st0;
-#line 2258 "edn_parser.cc"
+#line 2400 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 591 "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();
-    }
+#line 629 "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 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 606 "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 == nullptr) { 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();
+#line 644 "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 == nullptr) { 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 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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+               rb_ary_push(elems, e);
             }
-            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 = edn::util::call_module_fn(rb_mEDNT, 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;}
-        }
-    }
+         } else {
+            // no metadata.. just push it
+            rb_ary_push(elems, e);
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2317 "edn_parser.cc"
+#line 2459 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -2344,11 +2486,11 @@ case 3:
 		goto tr4;
 	goto st3;
 tr7:
-#line 601 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
+      // remove the current metadata level
+      del_top_meta_list();
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -2356,7 +2498,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2360 "edn_parser.cc"
+#line 2502 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2371,31 +2513,31 @@ case 4:
 	case 3:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	break;
-#line 2381 "edn_parser.cc"
+#line 2523 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 672 "edn_parser.rl"
+#line 710 "edn_parser.rl"
 
-    if (cs >= EDN_vector_first_final) {
-        v = elems;
-        return p + 1;
-    }
-    else if (cs == EDN_vector_error) {
-        error(__FUNCTION__, "vector format error", *p);
-        return pe;
-    }
-    else if (cs == EDN_vector_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_vector_first_final) {
+      v = elems;
+      return p + 1;
+   }
+   else if (cs == EDN_vector_error) {
+      error(__FUNCTION__, "vector format error", *p);
+      return pe;
+   }
+   else if (cs == EDN_vector_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -2404,7 +2546,7 @@ case 4:
 // list parsing machine
 //
 
-#line 2408 "edn_parser.cc"
+#line 2550 "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;
@@ -2412,7 +2554,7 @@ static const int EDN_list_error = 0;
 static const int EDN_list_en_main = 1;
 
 
-#line 701 "edn_parser.rl"
+#line 739 "edn_parser.rl"
 
 
 //
@@ -2420,20 +2562,20 @@ static const int EDN_list_en_main = 1;
 //
 const char* edn::Parser::parse_list(const char *p, const char *pe, VALUE& v)
 {
-    static const char* EDN_TYPE = "list";
+   static const char* EDN_TYPE = "list";
 
-    int cs;
-    VALUE elems; // stores the list's elements - allocated in @open_seq
+   int cs;
+   VALUE elems; // stores the list's elements - allocated in @open_seq
 
 
-#line 2430 "edn_parser.cc"
+#line 2572 "edn_parser.cc"
 	{
 	cs = EDN_list_start;
 	}
 
-#line 714 "edn_parser.rl"
+#line 752 "edn_parser.rl"
 
-#line 2437 "edn_parser.cc"
+#line 2579 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2446,72 +2588,72 @@ case 1:
 tr2:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	goto st0;
-#line 2456 "edn_parser.cc"
+#line 2598 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 591 "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();
-    }
+#line 629 "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 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 606 "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 == nullptr) { 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 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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
-                    rb_ary_push(elems, e);
-                }
-            } else {
-                // no metadata.. just push it
-                rb_ary_push(elems, e);
+#line 644 "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 == nullptr) { 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 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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+               rb_ary_push(elems, e);
             }
-            {p = (( np))-1;}
-        }
-    }
+         } else {
+            // no metadata.. just push it
+            rb_ary_push(elems, e);
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2515 "edn_parser.cc"
+#line 2657 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -2535,11 +2677,11 @@ case 2:
 		goto tr5;
 	goto tr2;
 tr6:
-#line 601 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
+      // remove the current metadata level
+      del_top_meta_list();
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -2547,7 +2689,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2551 "edn_parser.cc"
+#line 2693 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -2569,33 +2711,33 @@ case 3:
 	case 3:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	break;
-#line 2579 "edn_parser.cc"
+#line 2721 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 715 "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 = edn::util::call_module_fn(EDN_MAKE_LIST_METHOD, elems);
-        return p + 1;
-    }
-    else if (cs == EDN_list_error) {
-        error(__FUNCTION__, *p);
-        return pe;
-    }
-    else if (cs == EDN_list_en_main) {} // silence ragel warning
-    return nullptr;
+#line 753 "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 = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_LIST_METHOD, elems);
+      return p + 1;
+   }
+   else if (cs == EDN_list_error) {
+      error(__FUNCTION__, *p);
+      return pe;
+   }
+   else if (cs == EDN_list_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -2604,7 +2746,7 @@ case 3:
 // hash parsing
 //
 
-#line 2608 "edn_parser.cc"
+#line 2750 "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;
@@ -2612,28 +2754,28 @@ static const int EDN_map_error = 0;
 static const int EDN_map_en_main = 1;
 
 
-#line 747 "edn_parser.rl"
+#line 785 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_map(const char *p, const char *pe, VALUE& v)
 {
-    static const char* EDN_TYPE = "map";
+   static const char* EDN_TYPE = "map";
 
-    int cs;
-    // since we don't know whether we're looking at a key or value,
-    // initially store all elements in an array (allocated in @open_seq)
-    VALUE elems;
+   int cs;
+   // since we don't know whether we're looking at a key or value,
+   // initially store all elements in an array (allocated in @open_seq)
+   VALUE elems;
 
 
-#line 2630 "edn_parser.cc"
+#line 2772 "edn_parser.cc"
 	{
 	cs = EDN_map_start;
 	}
 
-#line 760 "edn_parser.rl"
+#line 798 "edn_parser.rl"
 
-#line 2637 "edn_parser.cc"
+#line 2779 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2646,72 +2788,72 @@ case 1:
 tr2:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	goto st0;
-#line 2656 "edn_parser.cc"
+#line 2798 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 591 "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();
-    }
+#line 629 "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 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 606 "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 == nullptr) { 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();
+#line 644 "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 == nullptr) { 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 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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+               rb_ary_push(elems, e);
             }
-            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 = edn::util::call_module_fn(rb_mEDNT, 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;}
-        }
-    }
+         } else {
+            // no metadata.. just push it
+            rb_ary_push(elems, e);
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2715 "edn_parser.cc"
+#line 2857 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -2745,11 +2887,11 @@ case 3:
 		goto tr4;
 	goto st3;
 tr7:
-#line 601 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
+      // remove the current metadata level
+      del_top_meta_list();
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -2757,7 +2899,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2761 "edn_parser.cc"
+#line 2903 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2772,45 +2914,44 @@ case 4:
 	case 3:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	break;
-#line 2782 "edn_parser.cc"
+#line 2924 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 761 "edn_parser.rl"
-
-    if (cs >= EDN_map_first_final) {
-
-        // hash parsing is done. Make sure we have an even count
-        if ((RARRAY_LEN(elems) % 2) != 0) {
-            error(__FUNCTION__, "odd number of elements in map");
-            return pe;
-        }
-
-        // now convert the sequence to a hash
-        VALUE rslt = rb_hash_new();
-        while (RARRAY_LEN(elems) > 0)
-        {
-            VALUE k = rb_ary_shift(elems);
-            rb_hash_aset(rslt, k, rb_ary_shift(elems));
-        }
-
-        v = rslt;
-        return p + 1;
-    }
-    else if (cs == EDN_map_error) {
-        return pe;
-    }
-    else if (cs == EDN_map_en_main) {} // silence ragel warning
-    return nullptr;
+#line 799 "edn_parser.rl"
+
+   if (cs >= EDN_map_first_final) {
+      // hash parsing is done. Make sure we have an even count
+      if ((RARRAY_LEN(elems) % 2) != 0) {
+         error(__FUNCTION__, "odd number of elements in map");
+         return pe;
+      }
+
+      // now convert the sequence to a hash
+      VALUE rslt = rb_hash_new();
+      while (RARRAY_LEN(elems) > 0)
+      {
+         VALUE k = rb_ary_shift(elems);
+         rb_hash_aset(rslt, k, rb_ary_shift(elems));
+      }
+
+      v = rslt;
+      return p + 1;
+   }
+   else if (cs == EDN_map_error) {
+      return pe;
+   }
+   else if (cs == EDN_map_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -2821,7 +2962,7 @@ case 4:
 // the remaining data to the correct parser
 //
 
-#line 2825 "edn_parser.cc"
+#line 2966 "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;
@@ -2829,23 +2970,23 @@ static const int EDN_dispatch_error = 0;
 static const int EDN_dispatch_en_main = 1;
 
 
-#line 825 "edn_parser.rl"
+#line 862 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_dispatch(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 2842 "edn_parser.cc"
+#line 2983 "edn_parser.cc"
 	{
 	cs = EDN_dispatch_start;
 	}
 
-#line 833 "edn_parser.rl"
+#line 870 "edn_parser.rl"
 
-#line 2849 "edn_parser.cc"
+#line 2990 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2866,32 +3007,32 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 813 "edn_parser.rl"
+#line 850 "edn_parser.rl"
 	{
-        // #inst, #uuid, or #user/tag
-        const char *np = parse_tagged(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // #inst, #uuid, or #user/tag
+      const char *np = parse_tagged(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr2:
-#line 807 "edn_parser.rl"
+#line 844 "edn_parser.rl"
 	{
-        // discard token #_
-        const char *np = parse_discard(p, pe);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // discard token #_
+      const char *np = parse_discard(p, pe);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr3:
-#line 801 "edn_parser.rl"
+#line 838 "edn_parser.rl"
 	{
-        // #{ }
-        const char *np = parse_set(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
-    }
+      // #{ }
+      const char *np = parse_set(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {p = (( np))-1;}
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
@@ -2899,7 +3040,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2903 "edn_parser.cc"
+#line 3044 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2908,18 +3049,17 @@ case 2:
 	_out: {}
 	}
 
-#line 834 "edn_parser.rl"
-
-    if (cs >= EDN_dispatch_first_final) {
-        return p + 1;
-    }
-    else if (cs == EDN_dispatch_error) {
-        error(__FUNCTION__, "dispatch extend error", *p);
-        return pe;
-    }
-    else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
+#line 871 "edn_parser.rl"
 
-    return nullptr;
+   if (cs >= EDN_dispatch_first_final) {
+      return p + 1;
+   }
+   else if (cs == EDN_dispatch_error) {
+      error(__FUNCTION__, "dispatch extend error", *p);
+      return pe;
+   }
+   else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -2927,7 +3067,7 @@ case 2:
 // set parsing machine
 //
 
-#line 2931 "edn_parser.cc"
+#line 3071 "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;
@@ -2935,7 +3075,7 @@ static const int EDN_set_error = 0;
 static const int EDN_set_en_main = 1;
 
 
-#line 863 "edn_parser.rl"
+#line 899 "edn_parser.rl"
 
 
 //
@@ -2943,20 +3083,20 @@ static const int EDN_set_en_main = 1;
 //
 const char* edn::Parser::parse_set(const char *p, const char *pe, VALUE& v)
 {
-    static const char* EDN_TYPE = "set";
+   static const char* EDN_TYPE = "set";
 
-    int cs;
-    VALUE elems; // holds the set's elements as an array allocated in @open_seq
+   int cs;
+   VALUE elems; // holds the set's elements as an array allocated in @open_seq
 
 
-#line 2953 "edn_parser.cc"
+#line 3093 "edn_parser.cc"
 	{
 	cs = EDN_set_start;
 	}
 
-#line 876 "edn_parser.rl"
+#line 912 "edn_parser.rl"
 
-#line 2960 "edn_parser.cc"
+#line 3100 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2969,72 +3109,72 @@ case 1:
 tr2:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	goto st0;
-#line 2979 "edn_parser.cc"
+#line 3119 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 591 "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();
-    }
+#line 629 "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 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 606 "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 == nullptr) { 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();
+#line 644 "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 == nullptr) { 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 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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, e, ruby_meta());
+               rb_ary_push(elems, e);
             }
-            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 = edn::util::call_module_fn(rb_mEDNT, 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;}
-        }
-    }
+         } else {
+            // no metadata.. just push it
+            rb_ary_push(elems, e);
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 3038 "edn_parser.cc"
+#line 3178 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -3068,11 +3208,11 @@ case 3:
 		goto tr4;
 	goto st3;
 tr7:
-#line 601 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
+      // remove the current metadata level
+      del_top_meta_list();
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -3080,7 +3220,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 3084 "edn_parser.cc"
+#line 3224 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -3095,32 +3235,32 @@ case 4:
 	case 3:
 #line 73 "edn_parser.rl"
 	{
-            std::stringstream s;
-            s << "unterminated " << EDN_TYPE;
-            error(__FUNCTION__, s.str());
-            p--; {p++; cs = 0; goto _out;}
-        }
+      std::stringstream s;
+      s << "unterminated " << EDN_TYPE;
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	break;
-#line 3105 "edn_parser.cc"
+#line 3245 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 877 "edn_parser.rl"
+#line 913 "edn_parser.rl"
 
-    if (cs >= EDN_set_first_final) {
-        // all elements collected; now convert to a set
-        v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SET_METHOD, elems);
-        return p + 1;
-    }
-    else if (cs == EDN_set_error) {
-        error(__FUNCTION__, *p);
-        return pe;
-    }
-    else if (cs == EDN_set_en_main) {} // silence ragel warning
-    return nullptr;
+   if (cs >= EDN_set_first_final) {
+      // all elements collected; now convert to a set
+      v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SET_METHOD, elems);
+      return p + 1;
+   }
+   else if (cs == EDN_set_error) {
+      error(__FUNCTION__, *p);
+      return pe;
+   }
+   else if (cs == EDN_set_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -3131,7 +3271,7 @@ case 4:
 // defining a machine to consume items within container delimiters
 //
 
-#line 3135 "edn_parser.cc"
+#line 3275 "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;
@@ -3139,24 +3279,24 @@ static const int EDN_discard_error = 0;
 static const int EDN_discard_en_main = 1;
 
 
-#line 927 "edn_parser.rl"
+#line 963 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_discard(const char *p, const char *pe)
 {
-    int cs;
-    VALUE v;
+   int cs;
+   VALUE v;
 
 
-#line 3153 "edn_parser.cc"
+#line 3293 "edn_parser.cc"
 	{
 	cs = EDN_discard_start;
 	}
 
-#line 936 "edn_parser.rl"
+#line 972 "edn_parser.rl"
 
-#line 3160 "edn_parser.cc"
+#line 3300 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3167,15 +3307,15 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 917 "edn_parser.rl"
+#line 953 "edn_parser.rl"
 	{
-        std::stringstream s;
-        s << "discard sequence without element to discard";
-        error(__FUNCTION__, s.str());
-        p--; {p++; cs = 0; goto _out;}
-    }
+      std::stringstream s;
+      s << "discard sequence without element to discard";
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	goto st0;
-#line 3179 "edn_parser.cc"
+#line 3319 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
@@ -3187,7 +3327,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 3191 "edn_parser.cc"
+#line 3331 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -3213,17 +3353,17 @@ case 2:
 		goto tr4;
 	goto tr2;
 tr4:
-#line 906 "edn_parser.rl"
-	{
-        const char *np = parse_value(p, pe, v);
-        if (np == nullptr) { 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;}
-        }
-    }
+#line 942 "edn_parser.rl"
+	{
+      const char *np = parse_value(p, pe, v);
+      if (np == nullptr) { 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;}
+      }
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
@@ -3231,7 +3371,7 @@ st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 3235 "edn_parser.cc"
+#line 3375 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -3250,33 +3390,32 @@ case 3:
 	{
 	switch ( cs ) {
 	case 2:
-#line 917 "edn_parser.rl"
+#line 953 "edn_parser.rl"
 	{
-        std::stringstream s;
-        s << "discard sequence without element to discard";
-        error(__FUNCTION__, s.str());
-        p--; {p++; cs = 0; goto _out;}
-    }
+      std::stringstream s;
+      s << "discard sequence without element to discard";
+      error(__FUNCTION__, s.str());
+      p--; {p++; cs = 0; goto _out;}
+   }
 	break;
-#line 3262 "edn_parser.cc"
+#line 3402 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 937 "edn_parser.rl"
+#line 973 "edn_parser.rl"
 
-    if (cs >= EDN_discard_first_final) {
-        return p + 1;
-    }
-    else if (cs == EDN_discard_error) {
-        error(__FUNCTION__, *p);
-        return pe;
-    }
-    else if (cs == EDN_discard_en_main) {} // silence ragel warning
-
-    return nullptr;
+   if (cs >= EDN_discard_first_final) {
+      return p + 1;
+   }
+   else if (cs == EDN_discard_error) {
+      error(__FUNCTION__, *p);
+      return pe;
+   }
+   else if (cs == EDN_discard_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -3296,7 +3435,7 @@ case 3:
 // 2. add parse checks for uuid and inst for better error reporting
 //
 
-#line 3300 "edn_parser.cc"
+#line 3439 "edn_parser.cc"
 static const int EDN_tagged_start = 1;
 static const int EDN_tagged_first_final = 7;
 static const int EDN_tagged_error = 0;
@@ -3304,28 +3443,28 @@ static const int EDN_tagged_error = 0;
 static const int EDN_tagged_en_main = 1;
 
 
-#line 1005 "edn_parser.rl"
+#line 1040 "edn_parser.rl"
 
 
 
 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;
+   VALUE sym_name = Qnil;
+   VALUE data = Qnil;
+   bool sym_ok = false;
+   bool data_ok = false;
 
-    int cs;
+   int cs;
 
 
-#line 3322 "edn_parser.cc"
+#line 3461 "edn_parser.cc"
 	{
 	cs = EDN_tagged_start;
 	}
 
-#line 1018 "edn_parser.rl"
+#line 1053 "edn_parser.rl"
 
-#line 3329 "edn_parser.cc"
+#line 3468 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3342,21 +3481,21 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 984 "edn_parser.rl"
-	{
-        // parses the symbol portion of the pair
-        const char *np = parse_symbol(p, pe, sym_name);
-        if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {
-            sym_ok = true;
-            {p = (( np))-1;}
-        }
-    }
+#line 1019 "edn_parser.rl"
+	{
+      // parses the symbol portion of the pair
+      const char *np = parse_symbol(p, pe, sym_name);
+      if (np == nullptr) { 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 3360 "edn_parser.cc"
+#line 3499 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
@@ -3389,7 +3528,7 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 3393 "edn_parser.cc"
+#line 3532 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
@@ -3415,15 +3554,15 @@ case 3:
 		goto tr7;
 	goto st0;
 tr7:
-#line 992 "edn_parser.rl"
-	{
-        // parses the value portion
-        const char *np = parse_value(p, pe, data);
-        if (np == nullptr) { p--; {p++; cs = 7; goto _out;} } else {
-            data_ok = true;
-            {p = (( np))-1;}
-        }
-    }
+#line 1027 "edn_parser.rl"
+	{
+      // parses the value portion
+      const char *np = parse_value(p, pe, data);
+      if (np == nullptr) { p--; {p++; cs = 7; goto _out;} } else {
+         data_ok = true;
+         {p = (( np))-1;}
+      }
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 7; goto _out;} }
 	goto st7;
@@ -3431,7 +3570,7 @@ st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 3435 "edn_parser.cc"
+#line 3574 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -3509,45 +3648,43 @@ case 6:
 	_out: {}
 	}
 
-#line 1019 "edn_parser.rl"
+#line 1054 "edn_parser.rl"
 
-    if (cs >= EDN_tagged_first_final) {
+   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 = EDN_EOF_CONST;
-            return nullptr;
-        }
-
-        try {
-            // tagged_element makes a call to ruby which may throw an
-            // exception when parsing the data
-            v = edn::util::call_module_fn(rb_mEDN, EDN_TAGGED_ELEM_METHOD, sym_name, data);
-            return p + 1;
-        } catch (std::exception& e) {
-            error(__FUNCTION__, e.what());
-            return pe;
-        }
-    }
-    else if (cs == EDN_tagged_error) {
-        error(__FUNCTION__, "tagged element symbol error", *p);
-    }
-    else if (cs == EDN_tagged_en_main) {} // silence ragel warning
-    v =  EDN_EOF_CONST;
-    return nullptr;
+      if (!sym_ok || !data_ok) {
+         error(__FUNCTION__, "tagged element symbol error", *p);
+         v = EDN_EOF_CONST;
+         return nullptr;
+      }
+
+      try {
+         // tagged_element makes a call to ruby which may throw an
+         // exception when parsing the data
+         v = edn::util::call_module_fn(rb_mEDN, EDN_TAGGED_ELEM_METHOD, sym_name, data);
+         return p + 1;
+      } catch (std::exception& e) {
+         error(__FUNCTION__, e.what());
+         return pe;
+      }
+   }
+   else if (cs == EDN_tagged_error) {
+      error(__FUNCTION__, "tagged element symbol error", *p);
+   }
+   else if (cs == EDN_tagged_en_main) {} // silence ragel warning
+   v =  EDN_EOF_CONST;
+   return nullptr;
 }
 
 
-
-
 // ============================================================
 // metadata - looks like ruby just discards this but we'll track it
 // and provide a means to retrive after each parse op - might be
 // useful?
 //
 
-#line 3551 "edn_parser.cc"
+#line 3688 "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;
@@ -3555,24 +3692,24 @@ static const int EDN_meta_error = 0;
 static const int EDN_meta_en_main = 1;
 
 
-#line 1069 "edn_parser.rl"
+#line 1102 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_meta(const char *p, const char *pe)
 {
-    int cs;
-    VALUE v;
+   int cs;
+   VALUE v;
 
 
-#line 3569 "edn_parser.cc"
+#line 3706 "edn_parser.cc"
 	{
 	cs = EDN_meta_start;
 	}
 
-#line 1078 "edn_parser.rl"
+#line 1111 "edn_parser.rl"
 
-#line 3576 "edn_parser.cc"
+#line 3713 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3611,11 +3748,11 @@ case 2:
 		goto tr2;
 	goto st0;
 tr2:
-#line 1061 "edn_parser.rl"
+#line 1094 "edn_parser.rl"
 	{
-        const char *np = parse_value(p, pe, v);
-        if (np == nullptr) { p--; {p++; cs = 3; goto _out;} } else { {p = (( np))-1;} }
-    }
+      const char *np = parse_value(p, pe, v);
+      if (np == nullptr) { p--; {p++; cs = 3; goto _out;} } else { {p = (( np))-1;} }
+   }
 #line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 3; goto _out;} }
 	goto st3;
@@ -3623,7 +3760,7 @@ st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 3627 "edn_parser.cc"
+#line 3764 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -3633,19 +3770,18 @@ case 3:
 	_out: {}
 	}
 
-#line 1079 "edn_parser.rl"
+#line 1112 "edn_parser.rl"
 
-    if (cs >= EDN_meta_first_final) {
-        append_to_meta(v);
-        return p + 1;
-    }
-    else if (cs == EDN_meta_error) {
-        error(__FUNCTION__, *p);
-        return pe;
-    }
-    else if (cs == EDN_meta_en_main) {} // silence ragel warning
-
-    return nullptr;
+   if (cs >= EDN_meta_first_final) {
+      append_to_meta(v);
+      return p + 1;
+   }
+   else if (cs == EDN_meta_error) {
+      error(__FUNCTION__, *p);
+      return pe;
+   }
+   else if (cs == EDN_meta_en_main) {} // silence ragel warning
+   return nullptr;
 }
 
 
@@ -3655,7 +3791,7 @@ case 3:
 // top-level, therefore, does not tokenize source stream
 //
 
-#line 3659 "edn_parser.cc"
+#line 3795 "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;
@@ -3663,25 +3799,25 @@ static const int EDN_parser_error = 0;
 static const int EDN_parser_en_main = 2;
 
 
-#line 1128 "edn_parser.rl"
+#line 1160 "edn_parser.rl"
 
 
 
 VALUE edn::Parser::parse(const char* src, std::size_t len)
 {
-    int cs;
-    VALUE result = EDN_EOF_CONST;
+   int cs;
+   VALUE result = EDN_EOF_CONST;
 
 
-#line 3677 "edn_parser.cc"
+#line 3813 "edn_parser.cc"
 	{
 	cs = EDN_parser_start;
 	}
 
-#line 1137 "edn_parser.rl"
-    set_source(src, len);
+#line 1169 "edn_parser.rl"
+   set_source(src, len);
 
-#line 3685 "edn_parser.cc"
+#line 3821 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3692,30 +3828,30 @@ tr1:
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 1105 "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_sz = meta_size();
-        const char* np = parse_value(p, pe, result);
-        if (np == nullptr) { {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 (!meta_empty() && meta_size() == meta_sz) {
-                // this will empty the metadata sequence too
-                result = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, result, ruby_meta());
-            }
-            {p = (( np))-1;}
-        }
-    }
+#line 1137 "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_sz = meta_size();
+      const char* np = parse_value(p, pe, result);
+      if (np == nullptr) { {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 (!meta_empty() && meta_size() == meta_sz) {
+            // this will empty the metadata sequence too
+            result = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, result, ruby_meta());
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 3719 "edn_parser.cc"
+#line 3855 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr1;
 		case 32: goto st2;
@@ -3758,17 +3894,17 @@ case 1:
 	_out: {}
 	}
 
-#line 1139 "edn_parser.rl"
+#line 1171 "edn_parser.rl"
 
-    if (cs == EDN_parser_error) {
-        error(__FUNCTION__, *p);
-        return EDN_EOF_CONST;
-    }
-    else if (cs == EDN_parser_first_final) {
-        p = pe = eof = nullptr;
-    }
-    else if (cs == EDN_parser_en_main) {} // silence ragel warning
-    return result;
+   if (cs == EDN_parser_error) {
+      error(__FUNCTION__, *p);
+      return EDN_EOF_CONST;
+   }
+   else if (cs == EDN_parser_first_final) {
+      p = pe = eof = nullptr;
+   }
+   else if (cs == EDN_parser_en_main) {} // silence ragel warning
+   return result;
 }
 
 
@@ -3776,13 +3912,13 @@ case 1:
 // token-by-token machine
 //
 
-#line 3780 "edn_parser.cc"
+#line 3916 "edn_parser.cc"
 static const int EDN_tokens_start = 1;
 
 static const int EDN_tokens_en_main = 1;
 
 
-#line 1193 "edn_parser.rl"
+#line 1225 "edn_parser.rl"
 
 
 
@@ -3790,25 +3926,25 @@ static const int EDN_tokens_en_main = 1;
 //
 edn::Parser::eTokenState edn::Parser::parse_next(VALUE& value)
 {
-    int cs;
-    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_sz;
+   int cs;
+   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_sz;
 
-    // clear any previously saved discards; only track if read during
-    // this op
-    discard.clear();
+   // clear any previously saved discards; only track if read during
+   // this op
+   discard.clear();
 
 
-#line 3805 "edn_parser.cc"
+#line 3941 "edn_parser.cc"
 	{
 	cs = EDN_tokens_start;
 	}
 
-#line 1211 "edn_parser.rl"
+#line 1243 "edn_parser.rl"
 
-#line 3812 "edn_parser.cc"
+#line 3948 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3822,7 +3958,7 @@ st1:
 	if ( ++p == pe )
 		goto _test_eof1;
 case 1:
-#line 3826 "edn_parser.cc"
+#line 3962 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr2;
 		case 32: goto st1;
@@ -3855,43 +3991,43 @@ tr6:
 	{ line_number++; }
 	goto st4;
 tr3:
-#line 1161 "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_sz = meta_size();
-
-        const char* np = parse_value(p, pe, value);
-        if (np == nullptr) { p--; {p++; cs = 4; goto _out;} } else {
-            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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, value, ruby_meta());
-                    state = TOKEN_OK;
-                }
-            } else if (!discard.empty()) {
-                // a discard read. Don't return a value
-                state = TOKEN_IS_DISCARD;
-            } else {
-                state = TOKEN_OK;
+#line 1193 "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_sz = meta_size();
+
+      const char* np = parse_value(p, pe, value);
+      if (np == nullptr) { p--; {p++; cs = 4; goto _out;} } else {
+         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 = edn::util::call_module_fn(rb_mEDNT, EDNT_EXTENDED_VALUE_METHOD, value, ruby_meta());
+               state = TOKEN_OK;
             }
-            {p = (( np))-1;}
-        }
-    }
+         } else if (!discard.empty()) {
+            // a discard read. Don't return a value
+            state = TOKEN_IS_DISCARD;
+         } else {
+            state = TOKEN_OK;
+         }
+         {p = (( np))-1;}
+      }
+   }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 3895 "edn_parser.cc"
+#line 4031 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr6;
 		case 32: goto st4;
@@ -3925,10 +4061,10 @@ case 3:
 	_out: {}
 	}
 
-#line 1212 "edn_parser.rl"
+#line 1244 "edn_parser.rl"
 
-    if (cs == EDN_tokens_en_main) {} // silence ragel warning
-    return state;
+   if (cs == EDN_tokens_en_main) {} // silence ragel warning
+   return state;
 }
 
 /*