diff --git a/test/basic_structures.cpp b/test/basic_structures.cpp
index 4a47e2fa..f9e60116 100644
--- a/test/basic_structures.cpp
+++ b/test/basic_structures.cpp
@@ -10,10 +10,5 @@
 #include <fstream>
 #include <string>
 
-#include <boost/spirit/include/classic_position_iterator.hpp>
-
-typedef std::string::const_iterator base_iterator_type;
-typedef boost::spirit::classic::position_iterator<base_iterator_type>
-    iterator_type;
-
-template struct yaml::parser::basic_structures<iterator_type>;
+typedef std::string::const_iterator char_iterator_t;
+template struct yaml::parser::basic_structures_t<char_iterator_t>;
diff --git a/test/block_style.cpp b/test/block_style.cpp
index 887d37ae..65d9e16a 100644
--- a/test/block_style.cpp
+++ b/test/block_style.cpp
@@ -10,10 +10,5 @@
 #include <fstream>
 #include <string>
 
-#include <boost/spirit/include/classic_position_iterator.hpp>
-
-typedef std::string::const_iterator base_iterator_type;
-typedef boost::spirit::classic::position_iterator<base_iterator_type>
-    iterator_type;
-
-template struct yaml::parser::block_styles<iterator_type>;
+typedef std::string::const_iterator char_iterator_t;
+template struct yaml::parser::block_styles_t<char_iterator_t>;
diff --git a/test/characters.cpp b/test/characters.cpp
index e371d289..5c7d46cf 100644
--- a/test/characters.cpp
+++ b/test/characters.cpp
@@ -10,10 +10,5 @@
 #include <fstream>
 #include <string>
 
-#include <boost/spirit/include/classic_position_iterator.hpp>
-
-typedef std::string::const_iterator base_iterator_type;
-typedef boost::spirit::classic::position_iterator<base_iterator_type>
-    iterator_type;
-
-template struct yaml::parser::characters<iterator_type>;
+typedef std::string::const_iterator char_iterator_t;
+template struct yaml::parser::characters_t<char_iterator_t>;
diff --git a/test/flow_style.cpp b/test/flow_style.cpp
index 79812088..9c3de910 100644
--- a/test/flow_style.cpp
+++ b/test/flow_style.cpp
@@ -10,10 +10,5 @@
 #include <fstream>
 #include <string>
 
-#include <boost/spirit/include/classic_position_iterator.hpp>
-
-typedef std::string::const_iterator base_iterator_type;
-typedef boost::spirit::classic::position_iterator<base_iterator_type>
-    iterator_type;
-
-template struct yaml::parser::flow_styles<iterator_type>;
+typedef std::string::const_iterator char_iterator_t;
+template struct yaml::parser::flow_styles_t<char_iterator_t>;
diff --git a/test/stream.cpp b/test/stream.cpp
index fdc3ede4..7def0acc 100644
--- a/test/stream.cpp
+++ b/test/stream.cpp
@@ -10,10 +10,5 @@
 #include <fstream>
 #include <string>
 
-#include <boost/spirit/include/classic_position_iterator.hpp>
-
-typedef std::string::const_iterator base_iterator_type;
-typedef boost::spirit::classic::position_iterator<base_iterator_type>
-    iterator_type;
-
-template struct yaml::parser::stream<iterator_type>;
+typedef std::string::const_iterator char_iterator_t;
+template struct yaml::parser::stream_t<char_iterator_t>;
diff --git a/yaml/parser/basic_structures.hpp b/yaml/parser/basic_structures.hpp
index 6de0ccaa..b9133715 100644
--- a/yaml/parser/basic_structures.hpp
+++ b/yaml/parser/basic_structures.hpp
@@ -40,46 +40,48 @@ namespace yaml { namespace parser {
     { return os << (s == eoi_state_t::not_at_end ? "not_at_end" : "at_end"); }
 #endif
 
-    template <typename Iterator>
-    struct basic_structures
+    template <typename CharIter>
+    struct basic_structures_t
     {
-        explicit basic_structures (boost::phoenix::function<error_handler_t> const & error_handler);
+        using iterator_t = pos_iterator<CharIter>;
 
-        characters<Iterator> characters_;
+        explicit basic_structures_t (boost::phoenix::function<error_handler_t> const & error_handler);
 
-        qi::rule<Iterator, void(int)> indent;    // indent exactly n spaces
-        qi::rule<Iterator, void(int)> indent_lt; // indent <= n spaces
-        qi::rule<Iterator, void(int)> indent_le; // indent < n spaces
-        qi::rule<Iterator, void()> separate_in_line;
-        qi::rule<Iterator, void(int, context_t)> line_prefix;
-        qi::rule<Iterator, void(int, context_t)> l_empty;
-        qi::rule<Iterator, char(int, context_t, bool stop_at_document_delimiter)> b_l_folded;
-        qi::rule<Iterator, char(int, bool stop_at_document_delimiter)> flow_folded;
-        qi::rule<Iterator, void()> comment_text;
-        qi::rule<Iterator, void(eoi_state_t &)> s_b_comment;
-        qi::rule<Iterator, void(eoi_state_t &)> l_comment;
-        qi::rule<Iterator, void(eoi_state_t &)> s_l_comments;
-        qi::rule<Iterator, void(int, context_t)> separate;
-        qi::rule<Iterator, void(int), qi::locals<eoi_state_t>> separate_lines;
+        characters_t<CharIter> characters_;
 
-        qi::rule<Iterator, qi::locals<eoi_state_t>> directive;
-        qi::rule<Iterator> reserved_directive;
-        qi::rule<Iterator, qi::locals<unsigned int>> yaml_directive;
-        qi::rule<Iterator> tag_directive;
-        qi::rule<Iterator> tag_handle;
-        qi::rule<Iterator> tag_prefix;
+        qi::rule<iterator_t, void(int)> indent;    // indent exactly n spaces
+        qi::rule<iterator_t, void(int)> indent_lt; // indent <= n spaces
+        qi::rule<iterator_t, void(int)> indent_le; // indent < n spaces
+        qi::rule<iterator_t, void()> separate_in_line;
+        qi::rule<iterator_t, void(int, context_t)> line_prefix;
+        qi::rule<iterator_t, void(int, context_t)> l_empty;
+        qi::rule<iterator_t, char(int, context_t, bool stop_at_document_delimiter)> b_l_folded;
+        qi::rule<iterator_t, char(int, bool stop_at_document_delimiter)> flow_folded;
+        qi::rule<iterator_t, void()> comment_text;
+        qi::rule<iterator_t, void(eoi_state_t &)> s_b_comment;
+        qi::rule<iterator_t, void(eoi_state_t &)> l_comment;
+        qi::rule<iterator_t, void(eoi_state_t &)> s_l_comments;
+        qi::rule<iterator_t, void(int, context_t)> separate;
+        qi::rule<iterator_t, void(int), qi::locals<eoi_state_t>> separate_lines;
+
+        qi::rule<iterator_t, qi::locals<eoi_state_t>> directive;
+        qi::rule<iterator_t> reserved_directive;
+        qi::rule<iterator_t, qi::locals<unsigned int>> yaml_directive;
+        qi::rule<iterator_t> tag_directive;
+        qi::rule<iterator_t> tag_handle;
+        qi::rule<iterator_t> tag_prefix;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             ast::properties_t(int, context_t),
             qi::locals<ast::string_t, ast::string_t>
         > properties;
 
-        qi::rule<Iterator, std::string()> tag_property;
-        qi::rule<Iterator, std::string()> anchor_property;
-        qi::rule<Iterator, std::string()> anchor_name;
+        qi::rule<iterator_t, std::string()> tag_property;
+        qi::rule<iterator_t, std::string()> anchor_property;
+        qi::rule<iterator_t, std::string()> anchor_name;
 
-        qi::rule<Iterator, void (eoi_state_t &)> one_time_eoi;
+        qi::rule<iterator_t, void (eoi_state_t &)> one_time_eoi;
 
         std::reference_wrapper<boost::phoenix::function<error_handler_t> const> error_handler_;
     };
diff --git a/yaml/parser/basic_structures_def.hpp b/yaml/parser/basic_structures_def.hpp
index 0d4f19d6..acf06760 100644
--- a/yaml/parser/basic_structures_def.hpp
+++ b/yaml/parser/basic_structures_def.hpp
@@ -86,8 +86,8 @@ namespace yaml { namespace parser {
 
     }
 
-    template <typename Iterator>
-    basic_structures<Iterator>::basic_structures (boost::phoenix::function<error_handler_t> const & error_handler)
+    template <typename CharIter>
+    basic_structures_t<CharIter>::basic_structures_t (boost::phoenix::function<error_handler_t> const & error_handler)
         : error_handler_ (error_handler)
     {
         qi::attr_type attr;
diff --git a/yaml/parser/block_styles.hpp b/yaml/parser/block_styles.hpp
index a9fb53db..7ea34686 100644
--- a/yaml/parser/block_styles.hpp
+++ b/yaml/parser/block_styles.hpp
@@ -47,79 +47,81 @@ namespace yaml { namespace parser {
 #endif
     };
 
-    template <typename Iterator>
-    struct block_styles
+    template <typename CharIter>
+    struct block_styles_t
     {
-        explicit block_styles (boost::phoenix::function<error_handler_t> const & error_handler);
+        using iterator_t = pos_iterator<CharIter>;
 
-        flow_styles<Iterator> flow_styles_;
+        explicit block_styles_t (boost::phoenix::function<error_handler_t> const & error_handler);
+
+        flow_styles_t<CharIter> flow_styles_;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             block_header_t(),
             qi::locals<int, chomping_t, eoi_state_t>
         > block_header;
 
-        qi::rule<Iterator, int()> indentation_indicator;
-        qi::rule<Iterator, chomping_t()> chomping_indicator;
-        qi::rule<Iterator, std::string(int, chomping_t)> chomped_empty;
-        qi::rule<Iterator, std::string(int)> strip_empty;
-        qi::rule<Iterator, std::string(int)> keep_empty;
-        qi::rule<Iterator, std::string(int), qi::locals<eoi_state_t>> trail_comments;
+        qi::rule<iterator_t, int()> indentation_indicator;
+        qi::rule<iterator_t, chomping_t()> chomping_indicator;
+        qi::rule<iterator_t, std::string(int, chomping_t)> chomped_empty;
+        qi::rule<iterator_t, std::string(int)> strip_empty;
+        qi::rule<iterator_t, std::string(int)> keep_empty;
+        qi::rule<iterator_t, std::string(int), qi::locals<eoi_state_t>> trail_comments;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             std::string(int),
             qi::locals<int, chomping_t>
         > literal;
 
-        qi::rule<Iterator, std::string(int)> literal_text;
-        qi::rule<Iterator, std::string(int)> literal_next;
-        qi::rule<Iterator, std::string(int, chomping_t)> literal_content;
+        qi::rule<iterator_t, std::string(int)> literal_text;
+        qi::rule<iterator_t, std::string(int)> literal_next;
+        qi::rule<iterator_t, std::string(int, chomping_t)> literal_content;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             std::string(int),
             qi::locals<int, chomping_t>
         > folded;
 
-        qi::rule<Iterator, std::string(int)> folded_text;
-        qi::rule<Iterator, std::string(int)> folded_lines;
-        qi::rule<Iterator, std::string(int)> spaced_text;
-        qi::rule<Iterator, std::string(int)> spaced;
-        qi::rule<Iterator, std::string(int)> spaced_lines;
-        qi::rule<Iterator, std::string(int)> same_lines;
-        qi::rule<Iterator, std::string(int)> diff_lines;
-        qi::rule<Iterator, std::string(int, chomping_t)> folded_content;
+        qi::rule<iterator_t, std::string(int)> folded_text;
+        qi::rule<iterator_t, std::string(int)> folded_lines;
+        qi::rule<iterator_t, std::string(int)> spaced_text;
+        qi::rule<iterator_t, std::string(int)> spaced;
+        qi::rule<iterator_t, std::string(int)> spaced_lines;
+        qi::rule<iterator_t, std::string(int)> same_lines;
+        qi::rule<iterator_t, std::string(int)> diff_lines;
+        qi::rule<iterator_t, std::string(int, chomping_t)> folded_content;
 
-        qi::rule<Iterator, int()> auto_detect_indent;
-        qi::rule<Iterator, ast::seq_t(int), qi::locals<int>> block_sequence;
-        qi::rule<Iterator, ast::value_t(int n)> block_seq_entry;
-        qi::rule<Iterator, ast::value_t(int n, context_t), qi::locals<int, eoi_state_t>> block_indented;
-        qi::rule<Iterator, ast::seq_t(int n)> compact_sequence;
+        qi::rule<iterator_t, int()> auto_detect_indent;
+        qi::rule<iterator_t, ast::seq_t(int), qi::locals<int>> block_sequence;
+        qi::rule<iterator_t, ast::value_t(int n)> block_seq_entry;
+        qi::rule<iterator_t, ast::value_t(int n, context_t), qi::locals<int, eoi_state_t>> block_indented;
+        qi::rule<iterator_t, ast::seq_t(int n)> compact_sequence;
 
-        qi::rule<Iterator, ast::map_t(int), qi::locals<int>> block_mapping;
-        qi::rule<Iterator, ast::map_element_t(int)> block_map_entry;
-        qi::rule<Iterator, ast::map_element_t(int)> block_map_explicit_entry;
-        qi::rule<Iterator, ast::value_t(int)> block_map_explicit_key;
-        qi::rule<Iterator, ast::value_t(int)> block_map_explicit_value;
-        qi::rule<Iterator, ast::map_element_t(int)> block_map_implicit_entry;
-        qi::rule<Iterator, ast::value_t()> block_map_implicit_key;
-        qi::rule<Iterator, ast::value_t(int), qi::locals<eoi_state_t>> block_map_implicit_value;
-        qi::rule<Iterator, ast::map_t(int)> compact_mapping;
+        qi::rule<iterator_t, ast::map_t(int), qi::locals<int>> block_mapping;
+        qi::rule<iterator_t, ast::map_element_t(int)> block_map_entry;
+        qi::rule<iterator_t, ast::map_element_t(int)> block_map_explicit_entry;
+        qi::rule<iterator_t, ast::value_t(int)> block_map_explicit_key;
+        qi::rule<iterator_t, ast::value_t(int)> block_map_explicit_value;
+        qi::rule<iterator_t, ast::map_element_t(int)> block_map_implicit_entry;
+        qi::rule<iterator_t, ast::value_t()> block_map_implicit_key;
+        qi::rule<iterator_t, ast::value_t(int), qi::locals<eoi_state_t>> block_map_implicit_value;
+        qi::rule<iterator_t, ast::map_t(int)> compact_mapping;
 
-        qi::rule<Iterator, ast::value_t(int, context_t)> block_node;
-        qi::rule<Iterator, ast::value_t(int), qi::locals<eoi_state_t>> flow_in_block;
-        qi::rule<Iterator, ast::value_t(int, context_t)> block_in_block;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> block_node;
+        qi::rule<iterator_t, ast::value_t(int), qi::locals<eoi_state_t>> flow_in_block;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> block_in_block;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             ast::value_t(int, context_t),
             qi::locals<ast::properties_t>
         > block_scalar;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             ast::value_t(int, context_t),
             qi::locals<ast::properties_t, eoi_state_t>
         > block_collection;
diff --git a/yaml/parser/block_styles_def.hpp b/yaml/parser/block_styles_def.hpp
index 929097d1..6673fa89 100644
--- a/yaml/parser/block_styles_def.hpp
+++ b/yaml/parser/block_styles_def.hpp
@@ -50,8 +50,8 @@ namespace yaml { namespace parser {
 
     }
 
-    template <typename Iterator>
-    block_styles<Iterator>::block_styles (boost::phoenix::function<error_handler_t> const & error_handler)
+    template <typename CharIter>
+    block_styles_t<CharIter>::block_styles_t (boost::phoenix::function<error_handler_t> const & error_handler)
         : flow_styles_ (error_handler)
     {
         qi::attr_type attr;
diff --git a/yaml/parser/characters.hpp b/yaml/parser/characters.hpp
index e1325f6d..09ffb787 100644
--- a/yaml/parser/characters.hpp
+++ b/yaml/parser/characters.hpp
@@ -16,6 +16,7 @@
 
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/qi_copy.hpp>
+#include <boost/spirit/include/classic_position_iterator.hpp>
 
 #include <string>
 
@@ -90,21 +91,26 @@ namespace yaml { namespace parser {
 
     using uchar_t = boost::uint32_t; // Unicode code point
 
-    template <typename Iterator>
-    struct characters
+    template <typename CharIter>
+    using pos_iterator = boost::spirit::classic::position_iterator<CharIter>;
+
+    template <typename CharIter>
+    struct characters_t
     {
-        characters ();
+        using iterator_t = pos_iterator<CharIter>;
 
-        qi::rule<Iterator, encoding_t()> full_bom;
+        characters_t ();
 
-        qi::rule<Iterator, char()> printable;
-        qi::rule<Iterator, char()> nb_json;
-        qi::rule<Iterator> bom;
-        qi::rule<Iterator, char()> nb_char;
-        qi::rule<Iterator, char()> ns_char;
-        qi::rule<Iterator, std::string()> uri_char;
-        qi::rule<Iterator, std::string()> tag_char;
-        qi::rule<Iterator, std::string()> esc_char;
+        qi::rule<iterator_t, encoding_t()> full_bom;
+
+        qi::rule<iterator_t, char()> printable;
+        qi::rule<iterator_t, char()> nb_json;
+        qi::rule<iterator_t> bom;
+        qi::rule<iterator_t, char()> nb_char;
+        qi::rule<iterator_t, char()> ns_char;
+        qi::rule<iterator_t, std::string()> uri_char;
+        qi::rule<iterator_t, std::string()> tag_char;
+        qi::rule<iterator_t, std::string()> esc_char;
     };
 
 } }
diff --git a/yaml/parser/characters_def.hpp b/yaml/parser/characters_def.hpp
index 5d54d1dc..2d260033 100644
--- a/yaml/parser/characters_def.hpp
+++ b/yaml/parser/characters_def.hpp
@@ -69,8 +69,8 @@ namespace yaml { namespace parser {
 
     }
 
-    template <typename Iterator>
-    characters<Iterator>::characters ()
+    template <typename CharIter>
+    characters_t<CharIter>::characters_t ()
     {
         qi::byte_type byte_;
         qi::char_type char_;
diff --git a/yaml/parser/error_handler.hpp b/yaml/parser/error_handler.hpp
index 328f996b..cfd4d34c 100644
--- a/yaml/parser/error_handler.hpp
+++ b/yaml/parser/error_handler.hpp
@@ -67,27 +67,27 @@ namespace yaml { namespace parser {
                 warning_fn_(msg);
         }
 
-        template <typename Iterator>
+        template <typename Iter>
         void operator() (
-            Iterator first,
-            Iterator last,
-            Iterator err_pos,
+            Iter first,
+            Iter last,
+            Iter err_pos,
             boost::spirit::info const & what
         ) const {
-            Iterator line_start = boost::spirit::get_line_start(first, err_pos);
+            Iter line_start = boost::spirit::get_line_start(first, err_pos);
             std::string error_line;
             if (line_start != last && *line_start == '\r')
                 ++line_start;
             if (line_start != last && *line_start == '\n')
                 ++line_start;
-            for (Iterator it = line_start; it != last; ++it) {
-                typename Iterator::value_type c = *it;
+            for (Iter it = line_start; it != last; ++it) {
+                typename Iter::value_type c = *it;
                 if (c == '\r' || c == '\n')
                     break;
                 error_line += c;
             }
 
-            typename Iterator::position_t const pos = err_pos.get_position();
+            typename Iter::position_t const pos = err_pos.get_position();
             int const line = pos.line;
             int const column = pos.column;
 
diff --git a/yaml/parser/flow_styles.hpp b/yaml/parser/flow_styles.hpp
index 8b8742aa..903ceb4f 100644
--- a/yaml/parser/flow_styles.hpp
+++ b/yaml/parser/flow_styles.hpp
@@ -43,84 +43,86 @@ namespace yaml { namespace parser {
 
     }
 
-    template <typename Iterator>
-    struct flow_styles
+    template <typename CharIter>
+    struct flow_styles_t
     {
-        explicit flow_styles (boost::phoenix::function<error_handler_t> const & error_handler);
+        using iterator_t = pos_iterator<CharIter>;
 
-        basic_structures<Iterator> basic_structures_;
+        explicit flow_styles_t (boost::phoenix::function<error_handler_t> const & error_handler);
+
+        basic_structures_t<CharIter> basic_structures_;
 
         qi::symbols<char, ast::alias_t> anchors;
 
-        qi::rule<Iterator, ast::alias_t()> alias_node;
+        qi::rule<iterator_t, ast::alias_t()> alias_node;
 
-        qi::rule<Iterator, std::string()> nb_double_char;
-        qi::rule<Iterator, std::string()> ns_double_char;
-        qi::rule<Iterator, std::string(int, context_t)> double_quoted;
-        qi::rule<Iterator, std::string(int, context_t)> double_text;
-        qi::rule<Iterator, std::string(int)> double_escaped;
-        qi::rule<Iterator, std::string(int)> double_break;
-        qi::rule<Iterator, std::string()> double_in_line;
-        qi::rule<Iterator, std::string(int)> double_next_line;
-        qi::rule<Iterator, std::string(int)> double_multi_line;
+        qi::rule<iterator_t, std::string()> nb_double_char;
+        qi::rule<iterator_t, std::string()> ns_double_char;
+        qi::rule<iterator_t, std::string(int, context_t)> double_quoted;
+        qi::rule<iterator_t, std::string(int, context_t)> double_text;
+        qi::rule<iterator_t, std::string(int)> double_escaped;
+        qi::rule<iterator_t, std::string(int)> double_break;
+        qi::rule<iterator_t, std::string()> double_in_line;
+        qi::rule<iterator_t, std::string(int)> double_next_line;
+        qi::rule<iterator_t, std::string(int)> double_multi_line;
 
-        qi::rule<Iterator, char()> nb_single_char;
-        qi::rule<Iterator, char()> ns_single_char;
-        qi::rule<Iterator, std::string(int, context_t)> single_quoted;
-        qi::rule<Iterator, std::string(int, context_t)> single_text;
-        qi::rule<Iterator, std::string()> single_in_line;
-        qi::rule<Iterator, std::string(int)> single_next_line;
-        qi::rule<Iterator, std::string(int)> single_multi_line;
+        qi::rule<iterator_t, char()> nb_single_char;
+        qi::rule<iterator_t, char()> ns_single_char;
+        qi::rule<iterator_t, std::string(int, context_t)> single_quoted;
+        qi::rule<iterator_t, std::string(int, context_t)> single_text;
+        qi::rule<iterator_t, std::string()> single_in_line;
+        qi::rule<iterator_t, std::string(int)> single_next_line;
+        qi::rule<iterator_t, std::string(int)> single_multi_line;
 
-        qi::rule<Iterator, char(context_t)> plain_first;
-        qi::rule<Iterator, char(context_t)> plain_safe;
-        qi::rule<Iterator, std::string(context_t)> plain_char;
-        qi::rule<Iterator, std::string(int, context_t)> plain;
-        qi::rule<Iterator, std::string(context_t)> plain_in_line;
-        qi::rule<Iterator, std::string(context_t)> plain_one_line;
-        qi::rule<Iterator, std::string(int, context_t)> plain_next_line;
-        qi::rule<Iterator, std::string(int, context_t)> plain_multi_line;
+        qi::rule<iterator_t, char(context_t)> plain_first;
+        qi::rule<iterator_t, char(context_t)> plain_safe;
+        qi::rule<iterator_t, std::string(context_t)> plain_char;
+        qi::rule<iterator_t, std::string(int, context_t)> plain;
+        qi::rule<iterator_t, std::string(context_t)> plain_in_line;
+        qi::rule<iterator_t, std::string(context_t)> plain_one_line;
+        qi::rule<iterator_t, std::string(int, context_t)> plain_next_line;
+        qi::rule<iterator_t, std::string(int, context_t)> plain_multi_line;
 
-        qi::rule<Iterator, ast::seq_t(int, context_t)> flow_sequence;
-        qi::rule<Iterator, ast::seq_t(int, context_t)> flow_seq_entries;
-        qi::rule<Iterator, ast::value_t(int, context_t)> flow_seq_entry;
+        qi::rule<iterator_t, ast::seq_t(int, context_t)> flow_sequence;
+        qi::rule<iterator_t, ast::seq_t(int, context_t)> flow_seq_entries;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> flow_seq_entry;
 
-        qi::rule<Iterator, ast::map_t(int, context_t)> flow_mapping;
-        qi::rule<Iterator, ast::map_t(int, context_t)> flow_map_entries;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_map_entry;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_map_explicit_entry;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_map_implicit_entry;
+        qi::rule<iterator_t, ast::map_t(int, context_t)> flow_mapping;
+        qi::rule<iterator_t, ast::map_t(int, context_t)> flow_map_entries;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_map_entry;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_map_explicit_entry;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_map_implicit_entry;
 
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_map_yaml_key_entry;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_map_empty_key_entry;
-        qi::rule<Iterator, ast::value_t(int, context_t)> flow_map_separate_value;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_map_json_key_entry;
-        qi::rule<Iterator, ast::value_t(int, context_t)> flow_map_adjacent_value;
-        qi::rule<Iterator, ast::map_t(int, context_t)> flow_pair;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_pair_entry;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_pair_yaml_key_entry;
-        qi::rule<Iterator, ast::map_element_t(int, context_t)> flow_pair_json_key_entry;
-        qi::rule<Iterator, ast::value_t(context_t)> implicit_yaml_key;
-        qi::rule<Iterator, ast::value_t(context_t)> implicit_json_key;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_map_yaml_key_entry;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_map_empty_key_entry;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> flow_map_separate_value;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_map_json_key_entry;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> flow_map_adjacent_value;
+        qi::rule<iterator_t, ast::map_t(int, context_t)> flow_pair;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_pair_entry;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_pair_yaml_key_entry;
+        qi::rule<iterator_t, ast::map_element_t(int, context_t)> flow_pair_json_key_entry;
+        qi::rule<iterator_t, ast::value_t(context_t)> implicit_yaml_key;
+        qi::rule<iterator_t, ast::value_t(context_t)> implicit_json_key;
 
-        qi::rule<Iterator, ast::value_t(int, context_t)> flow_yaml_content;
-        qi::rule<Iterator, ast::value_t(int, context_t)> flow_json_content;
-        qi::rule<Iterator, ast::value_t(int, context_t)> flow_content;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> flow_yaml_content;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> flow_json_content;
+        qi::rule<iterator_t, ast::value_t(int, context_t)> flow_content;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             ast::value_t(int, context_t),
             qi::locals<ast::properties_t>
         > flow_yaml_node;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             ast::value_t(int, context_t),
             qi::locals<ast::properties_t>
         > flow_json_node;
 
         qi::rule<
-            Iterator,
+            iterator_t,
             ast::value_t(int, context_t),
             qi::locals<ast::properties_t>
         > flow_node;
diff --git a/yaml/parser/flow_styles_def.hpp b/yaml/parser/flow_styles_def.hpp
index b51c2845..fc2e1f3a 100644
--- a/yaml/parser/flow_styles_def.hpp
+++ b/yaml/parser/flow_styles_def.hpp
@@ -44,8 +44,8 @@ namespace yaml { namespace parser {
 
     }
 
-    template <typename Iterator>
-    flow_styles<Iterator>::flow_styles (boost::phoenix::function<error_handler_t> const & error_handler)
+    template <typename CharIter>
+    flow_styles_t<CharIter>::flow_styles_t (boost::phoenix::function<error_handler_t> const & error_handler)
         : basic_structures_ (error_handler)
     {
         qi::attr_type attr;
diff --git a/yaml/parser/stream.hpp b/yaml/parser/stream.hpp
index 4fca0cab..8b7114d6 100644
--- a/yaml/parser/stream.hpp
+++ b/yaml/parser/stream.hpp
@@ -20,27 +20,29 @@
 
 namespace yaml { namespace parser {
 
-    template <typename Iterator>
-    struct stream
+    template <typename CharIter>
+    struct stream_t
     {
-        stream (
+        using iterator_t = pos_iterator<CharIter>;
+
+        stream_t (
             std::string const & source_file,
             reporting_fn_t const & errors_callback,
             reporting_fn_t const & warnings_callback
         );
 
-        block_styles<Iterator> block_styles_;
+        block_styles_t<CharIter> block_styles_;
 
-        qi::rule<Iterator, qi::locals<eoi_state_t>> document_prefix;
-        qi::rule<Iterator, qi::locals<eoi_state_t>> document_suffix;
-        qi::rule<Iterator> forbidden;
-        qi::rule<Iterator, ast::value_t()> bare_document;
-        qi::rule<Iterator, ast::value_t(), qi::locals<eoi_state_t>> explicit_document;
-        qi::rule<Iterator, ast::value_t()> directive_document;
-        qi::rule<Iterator, ast::value_t()> any_document;
-        qi::rule<Iterator, std::vector<ast::value_t>()> yaml_stream;
+        qi::rule<iterator_t, qi::locals<eoi_state_t>> document_prefix;
+        qi::rule<iterator_t, qi::locals<eoi_state_t>> document_suffix;
+        qi::rule<iterator_t> forbidden;
+        qi::rule<iterator_t, ast::value_t()> bare_document;
+        qi::rule<iterator_t, ast::value_t(), qi::locals<eoi_state_t>> explicit_document;
+        qi::rule<iterator_t, ast::value_t()> directive_document;
+        qi::rule<iterator_t, ast::value_t()> any_document;
+        qi::rule<iterator_t, std::vector<ast::value_t>()> yaml_stream;
 
-        qi::rule<Iterator> end_of_input;
+        qi::rule<iterator_t> end_of_input;
 
         boost::phoenix::function<error_handler_t> const error_handler_;
     };
@@ -50,8 +52,8 @@ namespace yaml { namespace parser {
 #endif
     encoding_t read_bom (std::istream & is);
 
-    template <typename Iter>
-    encoding_t read_bom (Iter & first, Iter last);
+    template <typename CharIter>
+    encoding_t read_bom (pos_iterator<CharIter> & first, pos_iterator<CharIter> last);
 
 #if YAML_HEADER_ONLY
     inline
diff --git a/yaml/parser/stream_def.hpp b/yaml/parser/stream_def.hpp
index 3e782869..94f53d4c 100644
--- a/yaml/parser/stream_def.hpp
+++ b/yaml/parser/stream_def.hpp
@@ -14,7 +14,6 @@
 #include <boost/spirit/include/phoenix_core.hpp>
 #include <boost/spirit/include/phoenix_container.hpp>
 #include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/classic_position_iterator.hpp>
 
 
 namespace yaml { namespace parser {
@@ -38,8 +37,8 @@ namespace yaml { namespace parser {
 
     }
 
-    template <typename Iterator>
-    stream<Iterator>::stream (
+    template <typename CharIter>
+    stream_t<CharIter>::stream_t (
         std::string const & source_file,
         reporting_fn_t const & errors_callback,
         reporting_fn_t const & warnings_callback
@@ -223,10 +222,10 @@ namespace yaml { namespace parser {
         return retval;
     }
 
-    template <typename Iter>
-    encoding_t read_bom (Iter & first, Iter last)
+    template <typename CharIter>
+    encoding_t read_bom (pos_iterator<CharIter> & first, pos_iterator<CharIter> last)
     {
-        Iter it = first;
+        pos_iterator<CharIter> it = first;
         int size = 0;
         char buf[4];
         for (char & c : buf) {
@@ -254,12 +253,10 @@ namespace yaml { namespace parser {
     ) {
         boost::optional<std::vector<ast::value_t>> retval;
 
-        using base_iterator_type = std::string::const_iterator;
-        using iterator_type = boost::spirit::classic::position_iterator<
-            base_iterator_type
-        >;
+        using char_iterator_t = std::string::const_iterator;
+        using iterator_t = stream_t<char_iterator_t>::iterator_t;
 
-        stream<iterator_type> p(
+        stream_t<char_iterator_t> p(
             source_file,
             errors_callback,
             warnings_callback
@@ -272,11 +269,11 @@ namespace yaml { namespace parser {
         std::string contents;
         std::getline(is, contents, '\0');
 
-        base_iterator_type sfirst(contents.begin());
-        base_iterator_type slast(contents.end());
+        char_iterator_t sfirst(contents.begin());
+        char_iterator_t slast(contents.end());
 
-        iterator_type first(sfirst, slast);
-        iterator_type last;
+        iterator_t first(sfirst, slast);
+        iterator_t last;
         first.set_tabchars(1);
 
         std::vector<ast::value_t> documents;