edn_turbo 0.5.7 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 846fd6b6a142bea1696ae918087fc9ae2c89264b
-  data.tar.gz: 0a6c9520a17d1cd2967c1f0e61efba2bfbb40fde
+SHA256:
+  metadata.gz: 59342940a3cb92e4792239598d5a858376a2ed18ef78872ea2d6a00a4421e18b
+  data.tar.gz: 04e6d9ab8648b13a7e850ac0ea84d85464ac8e3474cde3642e83c9f9ac2a44c8
 SHA512:
-  metadata.gz: 4c4a5d4d8357b9bcf773cc3cfdb66d191f0248326c8772ef15c2ff31904740d3b4df1bea8db54edf5a0817b0bb55446bd064b1bf25ad721cd46ee5df2f7171cb
-  data.tar.gz: a4dc313919664ffd6881e9be561ec9453b77c78569ddb5726a7c8ef6e4c34ccaddab25385920cbcbd7ff811865cc8ae081fe58f880bae9fed179edce6f291c78
+  metadata.gz: 208f82034dec3313c9bc6eaacc46debb746d39379e385195ee727afce4a3e5cf26cb5f06336a137428409a2914caa3e6531138a8c36b2223620bb9920a82f024
+  data.tar.gz: ab5e07ba292a835729b5174973280253040ea9fdf78742ff46bd7afd271f1e9884173a4571cffd4a766f21eca9a2232edddee7b3e7c969472e888069fe60ea02

data/.dir-locals.el

@@ -0,0 +1,3 @@
+((c++-mode
+  (flycheck-clang-language-standard . "c++11")
+  (flycheck-gcc-language-standard . "c++11")))

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# 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.7.1 - 2021-02-07
+### Changed
+- Set minimum ruby version to 2.5
+
+### Fixed
+- Compilation error when building against ruby versions > 2
+
+## 0.7.0 - 2020-02-07
+### Added
+- big_decimal_edn_turbo method to replace calling edn-ruby's
+  big_decimal as it breaks things in ruby 2.7 and up
+
+### Changed
+- Removed compiler warning due to scalar wrapped in braces
+- Updated docker configs to use latest 2.4 and 2.6 ruby
+  versions. Added 2.5 and 2.7 too.
+
+## 0.6.2 - 2019-05-21
+### Fixed
+- Handling of ##Inf, ##Nan, et al.
+
+## 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.
+- replaced `NULL` with `nullptr`.
+- replaced old-style casts.
+- prohibit Parser copy and move ops.
+- assigning a source that does not respond to `read` now throws
+  `ArgumentError` instead of `RuntimeError`.
+
+### Added
+- initial version of docker configs for testing on Ubuntu.
+
+[Unreleased]: https://github.com/edporras/edn_turbo/-/compare/0.7.1...main
+[0.7.1]: https://github.com/edporras/edn_turbo/-/compare/0.7.0...0.7.1
+[0.7.0]: https://github.com/edporras/edn_turbo/-/compare/0.6.2...0.7.0
+[0.6.2]: https://github.com/edporras/edn_turbo/-/compare/0.6.1...0.6.2
+[0.6.1]: https://github.com/edporras/edn_turbo/-/compare/0.6.0...0.6.1
+[0.6.0]: https://github.com/edporras/edn_turbo/-/compare/0.5.7...0.6.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) <year> <copyright holders>
+Copyright (c) 2015-2019 Ed Porras
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,14 +1,13 @@
-edn_turbo 0.5.7
+edn_turbo 0.7.1
 ===============
 
-Fast Ragel-based EDN parser for Ruby.
+Fast [Ragel](http://www.colm.net/open-source/ragel/)-based EDN parser for Ruby.
 
-`edn_turbo` is a parser plugin for
+`edn_turbo` can be used as a parser plugin for
 [edn](https://github.com/relevance/edn-ruby). With a few exceptions
 `edn_turbo` provides the same functionality as the edn gem, but since
-the `edn_turbo` parser is implemented in C, it is an order of
-magintude faster.
-
+the `edn_turbo` parser is implemented in C++, it is an order of
+magnitude faster.
 
 Some quick sample runs comparing time output of file reads using `edn`
 and `edn_turbo` (see [issue 12](https://github.com/relevance/edn-ruby/issues/12)):
@@ -32,27 +31,24 @@ irb(main):008:0> Benchmark.realtime { 100000.times { EDN::read(s) } }
 => 2.866411
 ```
 
-
 Dependencies
 ============
 
+Ruby 2.6 or greater.
+
 - ruby gems:
   - [rake](http://rake.rubyforge.org)
   - [rake-compiler 1.0](http://rake-compiler.rubyforge.org)
   - [edn 1.1](https://github.com/relevance/edn-ruby)
+- a C++-11 capable compiler.
 - [icu4c](http://icu-project.org/apiref/icu4c/)
 
-
 Notes:
 ------
 
 - `edn_turbo` uses a ragel-based parser but the generated .cc file is
   bundled so ragel should not need to be installed.
 
-- If the gem fails to install due to a compilation error, make sure you
-  have `icu4c` installed. The reported gem install error doesn't make
-  it clear this is the issue.
-
 Usage
 =====
 
@@ -70,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}
 
 ```
 
@@ -107,16 +103,14 @@ Or instantiate and reuse an instance of a parser:
 
 Differences with edn gem
 ========================
-`edn_turbo` reads `String` and core IO types using C-api calls.
+- `edn_turbo` reads `String` and core IO types using C-api calls.
 However, data from `StringIO` sources is extracted using `read()`
 calls into the ruby side.
 
-Known problems
-==============
+- As of v0.6.1, `edn_turbo` supports EDN ratio literals, returning a
+  ruby Rational representation for them. See https://github.com/edn-format/edn/issues/64.
 
-v0.3.2:
+- As of v0.6.2, `edn_turbo` supports representation of `##Inf` as
+  `Float::INFINITY` and `##NaN` as `Float::NAN`.
 
-- Some unhandled corner cases with operators and spacing
-  remain. `edn_turbo` handles things like `1 / 12` and `1/ 12` but
-  parse errors occur with `1/12` and `1 /12` because it treats `/12`
-  as an invalid symbol.
+- As of v0.7.1, `edn_turbo` requires ruby 2.5 or greater.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rake/testtask'
 require 'rake/extensiontask'
 require 'rake/clean'
@@ -8,57 +10,50 @@ LIB_DIR = "lib/#{NAME}"
 EXT_BUNDLE = "#{LIB_DIR}/#{NAME}.#{RbConfig::CONFIG['DLEXT']}"
 
 EXT_PATH               = "ext/#{NAME}"
-RAGEL_PARSER_SRC       = "edn_parser.rl"
+RAGEL_PARSER_SRC       = 'edn_parser.rl'
 RAGEL_PARSER_SRC_PATH  = "#{EXT_PATH}/#{RAGEL_PARSER_SRC}"
-GEN_CC_PARSER_SRC      = "edn_parser.cc"
+GEN_CC_PARSER_SRC      = 'edn_parser.cc'
 GEN_CC_PARSER_SRC_PATH = "#{EXT_PATH}/#{GEN_CC_PARSER_SRC}"
 
 task :irb do
-  sh "irb -I lib -r edn_turbo"
-  sh "reset"
+  sh 'irb -I lib -r edn_turbo'
+  sh 'reset'
 end
 
-task :runthru => [:clean, :default, :test]
+task runthru: %i[clean default test]
 
-Rake::ExtensionTask.new("#{NAME}") do |extension|
+Rake::ExtensionTask.new(NAME) do |extension|
   extension.lib_dir = LIB_DIR
-  extension.source_pattern = "*.{cc,h}"
+  extension.source_pattern = '*.{cc,h}'
 end
 
 task :chmod do
-  File.chmod(0775, EXT_BUNDLE)
+  File.chmod(0o0775, EXT_BUNDLE)
 end
 
-CLEAN.include(["*.png", "*.gem"])
+CLEAN.include(['*.png', '*.gem'])
 
 # ragel cc source generation
-task :ragel => GEN_CC_PARSER_SRC_PATH
+task ragel: GEN_CC_PARSER_SRC_PATH
 file GEN_CC_PARSER_SRC_PATH => RAGEL_PARSER_SRC_PATH do
-  cd EXT_PATH do
+  Dir.chdir(EXT_PATH) do
     sh "ragel -G2 -o #{GEN_CC_PARSER_SRC} #{RAGEL_PARSER_SRC}"
     src = File.read(GEN_CC_PARSER_SRC).gsub(/[ \t]+$/, '')
-    File.open(GEN_CC_PARSER_SRC, "w") {|f| f.print src}
+    File.open(GEN_CC_PARSER_SRC, 'w') { |f| f.print src }
   end
 end
 
 # graph generation for testing machine output
-task :graph, [:machine] do |t, args|
-  args.with_defaults(:machine => 'EDN_value')
-  TMPFILE='/tmp/ragel_edn'
-  MACHINE=args[:machine]
+task :graph, %i[machine] do |_t, args|
+  args.with_defaults(machine: 'EDN_value')
+  tmpfile = '/tmp/ragel_edn'
+  machine = args[:machine]
 
   # assumes graphviz is installed
-  sh "ragel -Vp -S #{MACHINE} -o #{TMPFILE} #{EXT_PATH}/#{RAGEL_PARSER_SRC} && dot -Tpng #{TMPFILE} -o #{MACHINE}.png"
+  sh "ragel -Vp -S #{machine} -o #{tmpfile} #{EXT_PATH}/#{RAGEL_PARSER_SRC} && "\
+    "dot -Tpng #{tmpfile} -o #{machine}.png"
 end
 
-task :build => [:clean, :ragel, :compile, :chmod]
-
-# add dependency to test task
-task :test => EXT_BUNDLE
-
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/test_output_diff.rb']
-end
+task build: %i[clean ragel compile chmod]
 
-task :default => :compile
+task default: :compile

data/docker/Dockerfile

@@ -0,0 +1,40 @@
+FROM buildpack-deps:stretch
+MAINTAINER github@digressed.net
+ARG ruby_version
+
+ENV LC_ALL C.UTF-8
+
+USER root
+RUN groupadd -r ned -g 1000 && \
+    useradd -u 1000 -r -g ned -m -s /sbin/nologin -c "Docker image user" ned && \
+    mkdir /home/ned/bin && \
+    mkdir /home/ned/src && \
+    chown -R ned:ned /home/ned
+
+WORKDIR /home/ned/src
+
+# Update Ubuntu Software repository && update deps
+RUN apt-get update && \
+     apt-get install -y \
+     libicu-dev \
+     libreadline-dev \
+     ragel && \
+     rm -rf /var/lib/apt/lists/*
+
+USER ned
+
+ENV PATH "/home/ned/.rbenv/bin:/home/ned/.rbenv/shims:$PATH"
+
+# install rbenv
+RUN \curl -sL https://github.com/rbenv/rbenv-installer/raw/master/bin/rbenv-installer | bash - && \
+    eval "$(rbenv init -)"
+
+RUN rm -f .ruby-version
+
+# the specified ruby version
+RUN rbenv install $ruby_version && \
+    rbenv global $ruby_version
+
+COPY --chown=ned:ned . /home/ned/src
+
+ENTRYPOINT ["docker/entrypoint"]

data/docker/build

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+. docker/common.sh
+
+set -e
+
+set_ruby_ver $@
+
+docker build --build-arg ruby_version=$RUBY_VERSION -f docker/Dockerfile -t digressed/test:edn_turbo-rb-$RUBY_VERSION .
+docker tag "digressed/test:edn_turbo-rb-$RUBY_VERSION" "edn_turbo-rb-$RUBY_VERSION"
+docker push "digressed/test:edn_turbo-rb-$RUBY_VERSION"

data/docker/common.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+RUBY_MAJOR_VER=3.0
+
+function update_ruby_build()
+{
+    if [ -e "~/.rbenv/plugins/" ]; then
+        echo "Updating ruby-build definitions"
+
+        pushd ~/.rbenv/plugins/ruby-build/ >> /dev/null
+        git pull
+        popd >> /dev/null
+    fi
+}
+
+function set_ruby_ver()
+{
+    local args=("$@")
+
+    if [ ${#args[@]} -eq 0 ]; then
+        update_ruby_build
+        RUBY_VERSION=`ruby-build --definitions | grep  "^$RUBY_MAJOR_VER" | tail -1`
+    else
+        RUBY_VERSION=$1
+    fi
+
+    echo "Using ruby $RUBY_VERSION"
+}

data/docker/console

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+if [ $# -eq 0 ]; then
+    RUBY_VERSION=3.0.0
+else
+    RUBY_VERSION=$1
+fi
+
+echo "running on ruby ${RUBY_VERSION}"
+
+docker-compose -f docker/docker-compose.yml run rb-$RUBY_VERSION /bin/bash

data/docker/docker-compose.yml

@@ -0,0 +1,22 @@
+version: "3"
+services:
+
+  rb-3.0.0:
+    image: digressed/test:edn_turbo-rb-3.0.0
+    stdin_open: true
+    tty: true
+
+  rb-2.7.2:
+    image: digressed/test:edn_turbo-rb-2.7.2
+    stdin_open: true
+    tty: true
+
+  rb-2.6.6:
+    image: digressed/test:edn_turbo-rb-2.6.6
+    stdin_open: true
+    tty: true
+
+  rb-2.5.8:
+    image: digressed/test:edn_turbo-rb-2.5.8
+    stdin_open: true
+    tty: true

data/docker/entrypoint

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exec "$@"

data/docker/make-check

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -x -e
+
+gem install bundler &&
+    bundle && \
+    rake compile && \
+    bundle exec rspec

data/docker/run

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+. docker/common.sh
+
+set -e
+
+set_ruby_ver $@
+
+docker-compose -f docker/docker-compose.yml run rb-$RUBY_VERSION docker/make-check

data/ext/edn_turbo/edn_parser.cc

@@ -1,5 +1,27 @@
 
 #line 1 "edn_parser.rl"
+// The MIT License (MIT)
+
+// Copyright (c) 2015-2021 Ed Porras
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
 #include <iostream>
 #include <string>
 #include <sstream>
@@ -21,7 +43,7 @@
 //
 
 
-#line 59 "edn_parser.rl"
+#line 81 "edn_parser.rl"
 
 
 // ============================================================
@@ -29,7 +51,7 @@
 //
 
 
-#line 33 "edn_parser.cc"
+#line 55 "edn_parser.cc"
 static const int EDN_value_start = 1;
 static const int EDN_value_first_final = 2;
 static const int EDN_value_error = 0;
@@ -37,24 +59,24 @@ static const int EDN_value_error = 0;
 static const int EDN_value_en_main = 1;
 
 
-#line 175 "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 51 "edn_parser.cc"
+#line 73 "edn_parser.cc"
 	{
 	cs = EDN_value_start;
 	}
 
-#line 184 "edn_parser.rl"
+#line 211 "edn_parser.rl"
 
-#line 58 "edn_parser.cc"
+#line 80 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -97,124 +119,129 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 103 "edn_parser.rl"
+#line 130 "edn_parser.rl"
 	{
-        // stand-alone operators *, +, -, etc.
-        const char *np = parse_operator(p, pe, v);
-        if (np == NULL) { 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 71 "edn_parser.rl"
+#line 93 "edn_parser.rl"
 	{
-        // string types within double-quotes
-        const char *np = parse_string(p, pe, v);
-        if (np == NULL) { 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 155 "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 == NULL) { 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 137 "edn_parser.rl"
+#line 164 "edn_parser.rl"
 	{
-        // (
-        const char *np = parse_list(p, pe, v);
-        if (np == NULL) { 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 83 "edn_parser.rl"
+#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 == NULL) {
-            // 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 77 "edn_parser.rl"
+#line 99 "edn_parser.rl"
 	{
-        // tokens with a leading ':'
-        const char *np = parse_keyword(p, pe, v);
-        if (np == NULL) { 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 115 "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 = (( 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 131 "edn_parser.rl"
+#line 158 "edn_parser.rl"
 	{
-        // [
-        const char *np = parse_vector(p, pe, v);
-        if (np == NULL) { 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 109 "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 == NULL) { 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 149 "edn_parser.rl"
+#line 176 "edn_parser.rl"
 	{
-        // ^
-        const char *np = parse_meta(p, pe);
-        if (np == NULL) { 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 143 "edn_parser.rl"
+#line 170 "edn_parser.rl"
 	{
-        // {
-        const char *np = parse_map(p, pe, v);
-        if (np == NULL) { 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 )
 		goto _test_eof2;
 case 2:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
-#line 218 "edn_parser.cc"
+#line 245 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -223,17 +250,17 @@ case 2:
 	_out: {}
 	}
 
-#line 185 "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 NULL;
+#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;
 }
 
 
@@ -245,7 +272,7 @@ case 2:
 // ascii range is found.
 //
 
-#line 249 "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;
@@ -253,26 +280,26 @@ static const int EDN_string_error = 0;
 static const int EDN_string_en_main = 1;
 
 
-#line 230 "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 268 "edn_parser.cc"
+#line 295 "edn_parser.cc"
 	{
 	cs = EDN_string_start;
 	}
 
-#line 240 "edn_parser.rl"
-    const char* p_save = p;
+#line 267 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 276 "edn_parser.cc"
+#line 303 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -286,16 +313,16 @@ st0:
 cs = 0;
 	goto _out;
 tr2:
-#line 219 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 299 "edn_parser.cc"
+#line 326 "edn_parser.cc"
 	switch( (*p) ) {
 		case 34: goto tr3;
 		case 92: goto tr4;
@@ -304,34 +331,34 @@ case 2:
 		goto tr2;
 	goto st2;
 tr3:
-#line 211 "edn_parser.rl"
+#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 58 "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;
 st8:
 	if ( ++p == pe )
 		goto _test_eof8;
 case 8:
-#line 323 "edn_parser.cc"
+#line 350 "edn_parser.cc"
 	goto st0;
 tr4:
-#line 219 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st3;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 335 "edn_parser.cc"
+#line 362 "edn_parser.cc"
 	switch( (*p) ) {
 		case 34: goto tr2;
 		case 47: goto tr2;
@@ -345,16 +372,16 @@ case 3:
 	}
 	goto st2;
 tr5:
-#line 219 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 358 "edn_parser.cc"
+#line 385 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr6;
@@ -365,16 +392,16 @@ case 4:
 		goto tr6;
 	goto st0;
 tr6:
-#line 219 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 378 "edn_parser.cc"
+#line 405 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr7;
@@ -385,16 +412,16 @@ case 5:
 		goto tr7;
 	goto st0;
 tr7:
-#line 219 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 398 "edn_parser.cc"
+#line 425 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr8;
@@ -405,16 +432,16 @@ case 6:
 		goto tr8;
 	goto st0;
 tr8:
-#line 219 "edn_parser.rl"
+#line 246 "edn_parser.rl"
 	{
-        encode = true;
-    }
+      encode = true;
+   }
 	goto st7;
 st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 418 "edn_parser.cc"
+#line 445 "edn_parser.cc"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto tr2;
@@ -438,31 +465,31 @@ case 7:
 	{
 	switch ( cs ) {
 	case 2:
-#line 51 "edn_parser.rl"
+#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 450 "edn_parser.cc"
+#line 477 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 242 "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 NULL;
+   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;
 }
 
 
@@ -471,7 +498,7 @@ case 7:
 // keyword parsing
 //
 
-#line 475 "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;
@@ -479,24 +506,24 @@ static const int EDN_keyword_error = 0;
 static const int EDN_keyword_en_main = 1;
 
 
-#line 272 "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 492 "edn_parser.cc"
+#line 519 "edn_parser.cc"
 	{
 	cs = EDN_keyword_start;
 	}
 
-#line 280 "edn_parser.rl"
-    const char* p_save = p;
+#line 307 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 500 "edn_parser.cc"
+#line 527 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -563,14 +590,14 @@ case 3:
 		goto st3;
 	goto tr3;
 tr3:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 574 "edn_parser.cc"
+#line 601 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -609,55 +636,54 @@ case 5:
 	_out: {}
 	}
 
-#line 282 "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 NULL;
+#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 637 "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 315 "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 653 "edn_parser.cc"
+#line 679 "edn_parser.cc"
 	{
 	cs = EDN_decimal_start;
 	}
 
-#line 323 "edn_parser.rl"
-    const char* p_save = p;
+#line 349 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 661 "edn_parser.cc"
+#line 687 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -711,14 +737,14 @@ case 9:
 		goto st0;
 	goto tr10;
 tr10:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 10; goto _out;} }
 	goto st10;
 st10:
 	if ( ++p == pe )
 		goto _test_eof10;
 case 10:
-#line 722 "edn_parser.cc"
+#line 748 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -834,14 +860,14 @@ case 8:
 	_out: {}
 	}
 
-#line 325 "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 NULL;
+   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;
 }
 
 
@@ -849,30 +875,30 @@ case 8:
 // integer parsing machine - M suffix will return a BigNum
 //
 
-#line 853 "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 348 "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 868 "edn_parser.cc"
+#line 894 "edn_parser.cc"
 	{
 	cs = EDN_integer_start;
 	}
 
-#line 355 "edn_parser.rl"
-    const char* p_save = p;
+#line 381 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 876 "edn_parser.cc"
+#line 902 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -914,14 +940,14 @@ case 3:
 		goto st0;
 	goto tr4;
 tr4:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 925 "edn_parser.cc"
+#line 951 "edn_parser.cc"
 	goto st0;
 st5:
 	if ( ++p == pe )
@@ -962,17 +988,152 @@ case 6:
 	_out: {}
 	}
 
-#line 357 "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 NULL;
+   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:
@@ -982,7 +1143,7 @@ case 6:
 // 3. stand-alone operators: +, -, /, *, etc.
 //
 
-#line 986 "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;
@@ -990,24 +1151,24 @@ static const int EDN_operator_error = 0;
 static const int EDN_operator_en_main = 1;
 
 
-#line 431 "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 1003 "edn_parser.cc"
+#line 1164 "edn_parser.cc"
 	{
 	cs = EDN_operator_start;
 	}
 
-#line 439 "edn_parser.rl"
-    const char* p_save = p;
+#line 501 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 1011 "edn_parser.cc"
+#line 1172 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1060,84 +1221,84 @@ case 3:
 		goto tr9;
 	goto tr6;
 tr6:
-#line 415 "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);
-    }
-#line 58 "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);
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 tr11:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 tr17:
-#line 381 "edn_parser.rl"
+#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 == NULL) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
-#line 58 "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;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 1097 "edn_parser.cc"
+#line 1258 "edn_parser.cc"
 	goto st0;
 tr5:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st5;
 tr7:
-#line 415 "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);
-    }
-#line 58 "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);
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 tr8:
-#line 415 "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);
-    }
-#line 25 "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);
+   }
+#line 47 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 tr12:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 tr13:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 1141 "edn_parser.cc"
+#line 1302 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr13;
 		case 32: goto tr12;
@@ -1162,25 +1323,25 @@ case 5:
 		goto st0;
 	goto tr11;
 tr10:
-#line 415 "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);
-    }
-#line 58 "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);
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 tr14:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 1184 "edn_parser.cc"
+#line 1345 "edn_parser.cc"
 	if ( (*p) == 10 )
 		goto tr5;
 	goto st2;
@@ -1192,48 +1353,53 @@ case 2:
 		goto tr5;
 	goto st2;
 tr9:
-#line 381 "edn_parser.rl"
+#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 == NULL) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+      // 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 392 "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 == NULL) {
-            // 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 1237 "edn_parser.cc"
+#line 1403 "edn_parser.cc"
 	switch( (*p) ) {
 		case 33: goto st0;
 		case 95: goto st0;
@@ -1316,23 +1482,23 @@ case 9:
 		goto tr18;
 	goto tr17;
 tr18:
-#line 381 "edn_parser.rl"
+#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 == NULL) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+      // 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 1336 "edn_parser.cc"
+#line 1502 "edn_parser.cc"
 	switch( (*p) ) {
 		case 33: goto st10;
 		case 95: goto st10;
@@ -1405,47 +1571,47 @@ case 11:
 	{
 	switch ( cs ) {
 	case 9:
-#line 381 "edn_parser.rl"
+#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 == NULL) { {p = (( pe))-1;} } else {
-            if (sym != Qnil)
-                v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
-            {p = (( np))-1;}
-        }
-    }
+      // 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 415 "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 1432 "edn_parser.cc"
+#line 1598 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 441 "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 NULL;
+#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;
 }
 
 
@@ -1454,7 +1620,7 @@ case 11:
 // escaped char parsing - handles \c, \newline, \formfeed, etc.
 //
 
-#line 1458 "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;
@@ -1462,24 +1628,24 @@ static const int EDN_escaped_char_error = 0;
 static const int EDN_escaped_char_en_main = 1;
 
 
-#line 471 "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 1475 "edn_parser.cc"
+#line 1641 "edn_parser.cc"
 	{
 	cs = EDN_escaped_char_start;
 	}
 
-#line 479 "edn_parser.rl"
-    const char* p_save = p;
+#line 541 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 1483 "edn_parser.cc"
+#line 1649 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1524,20 +1690,20 @@ case 26:
 		goto tr28;
 	goto st0;
 tr10:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 27; goto _out;} }
 	goto st27;
 tr28:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 27; goto _out;} }
 	goto st27;
 st27:
 	if ( ++p == pe )
 		goto _test_eof27;
 case 27:
-#line 1541 "edn_parser.cc"
+#line 1707 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr10;
 		case 32: goto tr28;
@@ -1555,14 +1721,14 @@ case 3:
 		goto tr10;
 	goto st3;
 tr29:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 28; goto _out;} }
 	goto st28;
 st28:
 	if ( ++p == pe )
 		goto _test_eof28;
 case 28:
-#line 1566 "edn_parser.cc"
+#line 1732 "edn_parser.cc"
 	goto st0;
 st29:
 	if ( ++p == pe )
@@ -1871,26 +2037,25 @@ case 25:
 	_out: {}
 	}
 
-#line 481 "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 NULL;
+#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,
@@ -1898,7 +2063,7 @@ case 25:
 //
 //
 
-#line 1902 "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;
@@ -1906,24 +2071,24 @@ static const int EDN_symbol_error = 0;
 static const int EDN_symbol_en_main = 1;
 
 
-#line 532 "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 1919 "edn_parser.cc"
+#line 2084 "edn_parser.cc"
 	{
 	cs = EDN_symbol_start;
 	}
 
-#line 540 "edn_parser.rl"
-    const char* p_save = p;
+#line 601 "edn_parser.rl"
+   const char* p_save = p;
 
-#line 1927 "edn_parser.cc"
+#line 2092 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1985,34 +2150,34 @@ case 4:
 		goto st4;
 	goto tr7;
 tr7:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 5; goto _out;} }
 	goto st5;
 st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 1996 "edn_parser.cc"
+#line 2161 "edn_parser.cc"
 	goto st0;
 tr4:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st6;
 tr8:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 tr9:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 6; goto _out;} }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 2016 "edn_parser.cc"
+#line 2181 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr9;
 		case 32: goto tr8;
@@ -2037,14 +2202,14 @@ case 6:
 		goto st0;
 	goto tr7;
 tr11:
-#line 58 "edn_parser.rl"
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 7; goto _out;} }
 	goto st7;
 st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 2048 "edn_parser.cc"
+#line 2213 "edn_parser.cc"
 	if ( (*p) == 10 )
 		goto tr4;
 	goto st2;
@@ -2152,24 +2317,23 @@ case 9:
 	_out: {}
 	}
 
-#line 542 "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 NULL;
+#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
@@ -2177,13 +2341,13 @@ case 9:
 // sets the same array is used)
 //
 
-#line 620 "edn_parser.rl"
+#line 680 "edn_parser.rl"
 
 
 //
 // vector-specific machine
 
-#line 2187 "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;
@@ -2191,7 +2355,7 @@ static const int EDN_vector_error = 0;
 static const int EDN_vector_en_main = 1;
 
 
-#line 635 "edn_parser.rl"
+#line 695 "edn_parser.rl"
 
 
 
@@ -2200,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 2210 "edn_parser.cc"
+#line 2374 "edn_parser.cc"
 	{
 	cs = EDN_vector_start;
 	}
 
-#line 649 "edn_parser.rl"
+#line 709 "edn_parser.rl"
 
-#line 2217 "edn_parser.cc"
+#line 2381 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2224,74 +2388,74 @@ case 1:
 		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#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 2236 "edn_parser.cc"
+#line 2400 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 569 "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 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 584 "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 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 2295 "edn_parser.cc"
+#line 2459 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -2322,19 +2486,19 @@ case 3:
 		goto tr4;
 	goto st3;
 tr7:
-#line 579 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
-#line 58 "edn_parser.rl"
+      // remove the current metadata level
+      del_top_meta_list();
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2338 "edn_parser.cc"
+#line 2502 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2347,33 +2511,33 @@ case 4:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#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 2359 "edn_parser.cc"
+#line 2523 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 650 "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 NULL;
+#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;
 }
 
 
@@ -2382,7 +2546,7 @@ case 4:
 // list parsing machine
 //
 
-#line 2386 "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;
@@ -2390,7 +2554,7 @@ static const int EDN_list_error = 0;
 static const int EDN_list_en_main = 1;
 
 
-#line 679 "edn_parser.rl"
+#line 739 "edn_parser.rl"
 
 
 //
@@ -2398,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 2408 "edn_parser.cc"
+#line 2572 "edn_parser.cc"
 	{
 	cs = EDN_list_start;
 	}
 
-#line 692 "edn_parser.rl"
+#line 752 "edn_parser.rl"
 
-#line 2415 "edn_parser.cc"
+#line 2579 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2422,74 +2586,74 @@ case 1:
 		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#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 2434 "edn_parser.cc"
+#line 2598 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 569 "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 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 584 "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 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 2493 "edn_parser.cc"
+#line 2657 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -2513,19 +2677,19 @@ case 2:
 		goto tr5;
 	goto tr2;
 tr6:
-#line 579 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
-#line 58 "edn_parser.rl"
+      // remove the current metadata level
+      del_top_meta_list();
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2529 "edn_parser.cc"
+#line 2693 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -2545,35 +2709,33 @@ case 3:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#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 2557 "edn_parser.cc"
+#line 2721 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 693 "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 NULL;
+#line 753 "edn_parser.rl"
+
+   if (cs >= EDN_list_first_final) {
+      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;
 }
 
 
@@ -2582,7 +2744,7 @@ case 3:
 // hash parsing
 //
 
-#line 2586 "edn_parser.cc"
+#line 2748 "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;
@@ -2590,28 +2752,28 @@ static const int EDN_map_error = 0;
 static const int EDN_map_en_main = 1;
 
 
-#line 725 "edn_parser.rl"
+#line 783 "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 2608 "edn_parser.cc"
+#line 2770 "edn_parser.cc"
 	{
 	cs = EDN_map_start;
 	}
 
-#line 738 "edn_parser.rl"
+#line 796 "edn_parser.rl"
 
-#line 2615 "edn_parser.cc"
+#line 2777 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2622,74 +2784,74 @@ case 1:
 		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#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 2634 "edn_parser.cc"
+#line 2796 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 569 "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 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 584 "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 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 2693 "edn_parser.cc"
+#line 2855 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -2723,19 +2885,19 @@ case 3:
 		goto tr4;
 	goto st3;
 tr7:
-#line 579 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
-#line 58 "edn_parser.rl"
+      // remove the current metadata level
+      del_top_meta_list();
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 2739 "edn_parser.cc"
+#line 2901 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2748,47 +2910,46 @@ case 4:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#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 2760 "edn_parser.cc"
+#line 2922 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 739 "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 NULL;
+#line 797 "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;
 }
 
 
@@ -2799,7 +2960,7 @@ case 4:
 // the remaining data to the correct parser
 //
 
-#line 2803 "edn_parser.cc"
+#line 2964 "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;
@@ -2807,23 +2968,23 @@ static const int EDN_dispatch_error = 0;
 static const int EDN_dispatch_en_main = 1;
 
 
-#line 803 "edn_parser.rl"
+#line 879 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_dispatch(const char *p, const char *pe, VALUE& v)
 {
-    int cs;
+   int cs;
 
 
-#line 2820 "edn_parser.cc"
+#line 2981 "edn_parser.cc"
 	{
 	cs = EDN_dispatch_start;
 	}
 
-#line 811 "edn_parser.rl"
+#line 887 "edn_parser.rl"
 
-#line 2827 "edn_parser.cc"
+#line 2988 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2831,53 +2992,77 @@ const char* edn::Parser::parse_dispatch(const char *p, const char *pe, VALUE& v)
 	{
 case 1:
 	switch( (*p) ) {
-		case 95: goto tr2;
-		case 123: goto tr3;
+		case 35: goto tr0;
+		case 95: goto tr3;
+		case 123: goto tr4;
 	}
 	if ( (*p) > 90 ) {
 		if ( 97 <= (*p) && (*p) <= 122 )
-			goto tr0;
+			goto tr2;
 	} else if ( (*p) >= 65 )
-		goto tr0;
+		goto tr2;
 	goto st0;
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 791 "edn_parser.rl"
+#line 854 "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"
+      // ##Inf, ##NaN, etc.
+      VALUE sym = Qnil;
+      const char *np = parse_symbol(p+1, pe, sym);
+      if (np == nullptr) { p--; {p++; cs = 2; goto _out;} } else {
+         if (std::strcmp(RSTRING_PTR(sym), "NaN") == 0) {
+            v = RUBY_NAN_CONST;
+         }
+         else if (std::strcmp(RSTRING_PTR(sym), "Inf") == 0) {
+            v = RUBY_INF_CONST;
+         }
+         else {
+            v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
+         }
+
+         {p = (( np))-1;}
+      }
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 2; goto _out;} }
 	goto st2;
 tr2:
-#line 785 "edn_parser.rl"
+#line 848 "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"
+      // #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;
 tr3:
-#line 779 "edn_parser.rl"
+#line 842 "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;}
+   }
+#line 80 "edn_parser.rl"
+	{ p--; {p++; cs = 2; goto _out;} }
+	goto st2;
+tr4:
+#line 836 "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"
+      // #{ }
+      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;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 2881 "edn_parser.cc"
+#line 3066 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -2886,18 +3071,17 @@ case 2:
 	_out: {}
 	}
 
-#line 812 "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
-
-    return NULL;
+#line 888 "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
+   return nullptr;
 }
 
 
@@ -2905,7 +3089,7 @@ case 2:
 // set parsing machine
 //
 
-#line 2909 "edn_parser.cc"
+#line 3093 "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;
@@ -2913,7 +3097,7 @@ static const int EDN_set_error = 0;
 static const int EDN_set_en_main = 1;
 
 
-#line 841 "edn_parser.rl"
+#line 916 "edn_parser.rl"
 
 
 //
@@ -2921,20 +3105,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 2931 "edn_parser.cc"
+#line 3115 "edn_parser.cc"
 	{
 	cs = EDN_set_start;
 	}
 
-#line 854 "edn_parser.rl"
+#line 929 "edn_parser.rl"
 
-#line 2938 "edn_parser.cc"
+#line 3122 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -2945,74 +3129,74 @@ case 1:
 		goto tr0;
 	goto st0;
 tr2:
-#line 51 "edn_parser.rl"
+#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 2957 "edn_parser.cc"
+#line 3141 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 569 "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 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr5:
-#line 584 "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 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 3016 "edn_parser.cc"
+#line 3200 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr4;
 		case 32: goto st2;
@@ -3046,19 +3230,19 @@ case 3:
 		goto tr4;
 	goto st3;
 tr7:
-#line 579 "edn_parser.rl"
+#line 639 "edn_parser.rl"
 	{
-        // remove the current metadata level
-        del_top_meta_list();
-    }
-#line 58 "edn_parser.rl"
+      // remove the current metadata level
+      del_top_meta_list();
+   }
+#line 80 "edn_parser.rl"
 	{ p--; {p++; cs = 4; goto _out;} }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 3062 "edn_parser.cc"
+#line 3246 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -3071,34 +3255,34 @@ case 4:
 	switch ( cs ) {
 	case 2:
 	case 3:
-#line 51 "edn_parser.rl"
+#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 3083 "edn_parser.cc"
+#line 3267 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 855 "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 NULL;
+#line 930 "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;
 }
 
 
@@ -3109,7 +3293,7 @@ case 4:
 // defining a machine to consume items within container delimiters
 //
 
-#line 3113 "edn_parser.cc"
+#line 3297 "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;
@@ -3117,24 +3301,24 @@ static const int EDN_discard_error = 0;
 static const int EDN_discard_en_main = 1;
 
 
-#line 905 "edn_parser.rl"
+#line 980 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_discard(const char *p, const char *pe)
 {
-    int cs;
-    VALUE v;
+   int cs;
+   VALUE v;
 
 
-#line 3131 "edn_parser.cc"
+#line 3315 "edn_parser.cc"
 	{
 	cs = EDN_discard_start;
 	}
 
-#line 914 "edn_parser.rl"
+#line 989 "edn_parser.rl"
 
-#line 3138 "edn_parser.cc"
+#line 3322 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3145,27 +3329,27 @@ case 1:
 		goto st2;
 	goto st0;
 tr2:
-#line 895 "edn_parser.rl"
+#line 970 "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 3157 "edn_parser.cc"
+#line 3341 "edn_parser.cc"
 st0:
 cs = 0;
 	goto _out;
 tr3:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 3169 "edn_parser.cc"
+#line 3353 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st2;
@@ -3191,25 +3375,25 @@ case 2:
 		goto tr4;
 	goto tr2;
 tr4:
-#line 884 "edn_parser.rl"
-	{
-        const char *np = parse_value(p, pe, v);
-        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;}
-        }
-    }
-#line 58 "edn_parser.rl"
+#line 959 "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;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 3213 "edn_parser.cc"
+#line 3397 "edn_parser.cc"
 	goto st0;
 st3:
 	if ( ++p == pe )
@@ -3228,33 +3412,32 @@ case 3:
 	{
 	switch ( cs ) {
 	case 2:
-#line 895 "edn_parser.rl"
+#line 970 "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 3240 "edn_parser.cc"
+#line 3424 "edn_parser.cc"
 	}
 	}
 
 	_out: {}
 	}
 
-#line 915 "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 NULL;
+#line 990 "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;
 }
 
 
@@ -3274,7 +3457,7 @@ case 3:
 // 2. add parse checks for uuid and inst for better error reporting
 //
 
-#line 3278 "edn_parser.cc"
+#line 3461 "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;
@@ -3282,28 +3465,28 @@ static const int EDN_tagged_error = 0;
 static const int EDN_tagged_en_main = 1;
 
 
-#line 983 "edn_parser.rl"
+#line 1057 "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 3300 "edn_parser.cc"
+#line 3483 "edn_parser.cc"
 	{
 	cs = EDN_tagged_start;
 	}
 
-#line 996 "edn_parser.rl"
+#line 1070 "edn_parser.rl"
 
-#line 3307 "edn_parser.cc"
+#line 3490 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3320,21 +3503,21 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 962 "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 {
-            sym_ok = true;
-            {p = (( np))-1;}
-        }
-    }
+#line 1036 "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 3338 "edn_parser.cc"
+#line 3521 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
@@ -3360,14 +3543,14 @@ case 2:
 		goto st2;
 	goto st0;
 tr3:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st3;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 3371 "edn_parser.cc"
+#line 3554 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr3;
 		case 32: goto st3;
@@ -3393,23 +3576,23 @@ case 3:
 		goto tr7;
 	goto st0;
 tr7:
-#line 970 "edn_parser.rl"
+#line 1044 "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 {
-            data_ok = true;
-            {p = (( np))-1;}
-        }
-    }
-#line 58 "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;
 st7:
 	if ( ++p == pe )
 		goto _test_eof7;
 case 7:
-#line 3413 "edn_parser.cc"
+#line 3596 "edn_parser.cc"
 	goto st0;
 st4:
 	if ( ++p == pe )
@@ -3487,45 +3670,43 @@ case 6:
 	_out: {}
 	}
 
-#line 997 "edn_parser.rl"
+#line 1071 "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 NULL;
-        }
-
-        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 NULL;
+      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 3529 "edn_parser.cc"
+#line 3710 "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;
@@ -3533,24 +3714,24 @@ static const int EDN_meta_error = 0;
 static const int EDN_meta_en_main = 1;
 
 
-#line 1047 "edn_parser.rl"
+#line 1119 "edn_parser.rl"
 
 
 
 const char* edn::Parser::parse_meta(const char *p, const char *pe)
 {
-    int cs;
-    VALUE v;
+   int cs;
+   VALUE v;
 
 
-#line 3547 "edn_parser.cc"
+#line 3728 "edn_parser.cc"
 	{
 	cs = EDN_meta_start;
 	}
 
-#line 1056 "edn_parser.rl"
+#line 1128 "edn_parser.rl"
 
-#line 3554 "edn_parser.cc"
+#line 3735 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -3589,19 +3770,19 @@ case 2:
 		goto tr2;
 	goto st0;
 tr2:
-#line 1039 "edn_parser.rl"
+#line 1111 "edn_parser.rl"
 	{
-        const char *np = parse_value(p, pe, v);
-        if (np == NULL) { p--; {p++; cs = 3; goto _out;} } else { {p = (( np))-1;} }
-    }
-#line 58 "edn_parser.rl"
+      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;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 3605 "edn_parser.cc"
+#line 3786 "edn_parser.cc"
 	goto st0;
 	}
 	_test_eof2: cs = 2; goto _test_eof;
@@ -3611,19 +3792,18 @@ case 3:
 	_out: {}
 	}
 
-#line 1057 "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 NULL;
+#line 1129 "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;
 }
 
 
@@ -3633,7 +3813,7 @@ case 3:
 // top-level, therefore, does not tokenize source stream
 //
 
-#line 3637 "edn_parser.cc"
+#line 3817 "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;
@@ -3641,59 +3821,59 @@ static const int EDN_parser_error = 0;
 static const int EDN_parser_en_main = 2;
 
 
-#line 1106 "edn_parser.rl"
+#line 1177 "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 3655 "edn_parser.cc"
+#line 3835 "edn_parser.cc"
 	{
 	cs = EDN_parser_start;
 	}
 
-#line 1115 "edn_parser.rl"
-    set_source(src, len);
+#line 1186 "edn_parser.rl"
+   set_source(src, len);
 
-#line 3663 "edn_parser.cc"
+#line 3843 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
 	switch ( cs )
 	{
 tr1:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st2;
 tr4:
-#line 1083 "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 == 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 (!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 1154 "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 3697 "edn_parser.cc"
+#line 3877 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr1;
 		case 32: goto st2;
@@ -3736,17 +3916,17 @@ case 1:
 	_out: {}
 	}
 
-#line 1117 "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 = NULL;
-    }
-    else if (cs == EDN_parser_en_main) {} // silence ragel warning
-    return result;
+#line 1188 "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;
 }
 
 
@@ -3754,13 +3934,13 @@ case 1:
 // token-by-token machine
 //
 
-#line 3758 "edn_parser.cc"
+#line 3938 "edn_parser.cc"
 static const int EDN_tokens_start = 1;
 
 static const int EDN_tokens_en_main = 1;
 
 
-#line 1171 "edn_parser.rl"
+#line 1242 "edn_parser.rl"
 
 
 
@@ -3768,39 +3948,39 @@ 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 3783 "edn_parser.cc"
+#line 3963 "edn_parser.cc"
 	{
 	cs = EDN_tokens_start;
 	}
 
-#line 1189 "edn_parser.rl"
+#line 1260 "edn_parser.rl"
 
-#line 3790 "edn_parser.cc"
+#line 3970 "edn_parser.cc"
 	{
 	if ( p == pe )
 		goto _test_eof;
 	switch ( cs )
 	{
 tr2:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st1;
 st1:
 	if ( ++p == pe )
 		goto _test_eof1;
 case 1:
-#line 3804 "edn_parser.cc"
+#line 3984 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr2;
 		case 32: goto st1;
@@ -3829,47 +4009,47 @@ st0:
 cs = 0;
 	goto _out;
 tr6:
-#line 25 "edn_parser.rl"
+#line 47 "edn_parser.rl"
 	{ line_number++; }
 	goto st4;
 tr3:
-#line 1139 "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 == NULL) { 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 1210 "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 3873 "edn_parser.cc"
+#line 4053 "edn_parser.cc"
 	switch( (*p) ) {
 		case 10: goto tr6;
 		case 32: goto st4;
@@ -3903,10 +4083,10 @@ case 3:
 	_out: {}
 	}
 
-#line 1190 "edn_parser.rl"
+#line 1261 "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;
 }
 
 /*