In TransitionMap constructor, use initializer lists for pairs

spec/rules/rules_spec.cpp

@@ -29,37 +29,34 @@ Describe(Rules) {
         It(handles_symbols) {
             AssertThat(
                 symbol1->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { symbol1 },
-                    { rules::blank() }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { symbol1, rules::blank() }
+                })));
         }
 
         It(handles_characters) {
             AssertThat(
                 char1->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { char1 },
-                    { rules::blank() }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { char1, rules::blank() }
+                })));
         }
 
         It(handles_choices) {
             AssertThat(
                 rules::choice({ symbol1, symbol2 })->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { symbol1, symbol2 },
-                    { rules::blank(), rules::blank() }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { symbol1, rules::blank() },
+                    { symbol2, rules::blank() }
+                })));
         }
 
         It(handles_sequences) {
             AssertThat(
                 rules::seq({ symbol1, symbol2 })->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { symbol1 },
-                    { symbol2 }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { symbol1, symbol2 }
+                })));
         }
 
         It(handles_long_sequences) {
@@ -70,10 +67,9 @@ Describe(Rules) {
                     symbol3,
                     symbol4
                 })->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { symbol1 },
-                    { rules::seq({ symbol2, symbol3, symbol4 }) }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { symbol1, rules::seq({ symbol2, symbol3, symbol4 }) }
+                })));
         }
 
         It(handles_choices_with_common_starting_symbols) {
@@ -81,28 +77,29 @@ Describe(Rules) {
                 rules::choice({
                     rules::seq({ symbol1, symbol2 }),
                     rules::seq({ symbol1, symbol3 }) })->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { symbol1 },
-                    { rules::choice({ symbol2, symbol3 }) }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { symbol1, rules::choice({ symbol2, symbol3 }) }
+                })));
         }
 
         It(handles_strings) {
             AssertThat(
                 rules::str("bad")->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { rules::character('b') },
-                    { rules::seq({ rules::character('a'), rules::character('d') }) }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    {
+                        rules::character('b'),
+                        rules::seq({ rules::character('a'), rules::character('d') })
+                    }
+                })));
         }
 
         It(handles_patterns) {
             AssertThat(
                 rules::pattern("a|b")->transitions(),
-                EqualsTransitionMap(TransitionMap<rules::Rule>(
-                    { rules::character('a'), rules::character('b') },
-                    { rules::blank(), rules::blank() }
-                )));
+                EqualsTransitionMap(TransitionMap<rules::Rule>({
+                    { rules::character('a'), rules::blank() },
+                    { rules::character('b'), rules::blank() }
+                })));
         }
 };
 };

src/rules/char.cpp

@@ -13,7 +13,7 @@ namespace tree_sitter  {
         }
 
         TransitionMap<Rule> Char::transitions() const {
-            return TransitionMap<Rule>({ character(value) }, { blank() });
+            return TransitionMap<Rule>({{ character(value), blank() }});
         }
 
         bool Char::operator==(const Rule &rule) const {

src/rules/symbol.cpp

@@ -11,7 +11,7 @@ namespace tree_sitter  {
         }
 
         TransitionMap<Rule> Symbol::transitions() const {
-            return TransitionMap<Rule>({ sym(name) }, { blank() });
+            return TransitionMap<Rule>({{ sym(name) , blank() }});
         }
         
         bool Symbol::operator==(const Rule &rule) const {

src/transition_map.h

@@ -21,13 +21,7 @@ namespace tree_sitter {
         
         TransitionMap() : contents(contents_type()) {};
         
-        TransitionMap(std::initializer_list<rule_ptr> keys, std::initializer_list<mapped_ptr> values) : TransitionMap() {
-            auto value_iter(values.begin());
-            for (auto key_iter(keys.begin()); key_iter != keys.end(); ++key_iter) {
-                add(*key_iter, *value_iter);
-                ++value_iter;
-            }
-        }
+        TransitionMap(std::initializer_list<std::pair<rule_ptr, mapped_ptr>> pairs) : contents(pairs) {};
         
         typedef typename contents_type::const_iterator const_iterator;
         typedef typename contents_type::iterator iterator;
@@ -45,7 +39,7 @@ namespace tree_sitter {
             return contents.size();
         }
         
-        mapped_ptr operator[](rules::Rule const &on_rule) {
+        mapped_ptr operator[](rules::Rule const &on_rule) const {
             pair_type *pair = pair_for_key(on_rule);
             if (pair)
                 return pair->second;