fix push_front/push_back mixup

skius · Aug 10, 2023 · 9d55038 · 9d55038
1 parent dc8dda7
commit 9d55038
Show file tree

Hide file tree

Showing 2 changed files with 10 additions and 8 deletions.
diff --git a/docs/tutorials/Cargo.lock b/docs/tutorials/Cargo.lock
diff --git a/experimental/transliterator_parser/src/compile/rule_group_agg.rs b/experimental/transliterator_parser/src/compile/rule_group_agg.rs
@@ -182,7 +182,7 @@ impl<'p> ForwardRuleGroup<'p> {
 // contiguous C's keep the source order, but contiguous T's are reversed. Also the overall order
 // is reversed, of course.
 //
-// We do this by using VecDeque, push_back, and make_contiguous in the end.
+// We do this by using VecDeque, push_front, and make_contiguous in the end.
 #[derive(Debug, Clone)]
 pub(crate) struct ReverseRuleGroupAggregator<'p> {
     current: ReverseRuleGroup<'p>,
@@ -264,7 +264,7 @@ impl<'p> ReverseRuleGroupAggregator<'p> {
                 };
                 let vec_transform_group = transform_group.into(); // non-allocating conversion
                 self.groups
-                    .push_back((vec_transform_group, associated_conv_group));
+                    .push_front((vec_transform_group, associated_conv_group));
             }
         }
     }
@@ -277,7 +277,7 @@ impl<'p> ReverseRuleGroupAggregator<'p> {
         if let Some(conv_group) = self.preceding_conversion_group.take() {
             // a trailing conversion group in source order is the same as having a conversion
             // group as the first in-order group. we can just prepend an empty transform group.
-            self.groups.push_back((Vec::new(), conv_group));
+            self.groups.push_front((Vec::new(), conv_group));
         }
 
         self.groups.into() // non-allocating conversion
@@ -289,7 +289,7 @@ impl<'p> ReverseRuleGroupAggregator<'p> {
 enum ReverseRuleGroup<'p> {
     // because contiguous C's are aggregated in source-order, we can just use a Vec
     Conversion(Vec<UniConversionRule<'p>>),
-    // but contiguous T's are aggregated in reverse-order, so we need to use a VecDeque and push_back
+    // but contiguous T's are aggregated in reverse-order, so we need to use a VecDeque and push_front
     Transform(VecDeque<Cow<'p, parse::SingleId>>),
 }
 
@@ -306,7 +306,7 @@ impl<'p> ReverseRuleGroup<'p> {
 
     fn new_transform(rule: Cow<'p, parse::SingleId>) -> Self {
         let mut group = VecDeque::new();
-        group.push_back(rule);
+        group.push_front(rule);
         Self::Transform(group)
     }
 
@@ -319,8 +319,8 @@ impl<'p> ReverseRuleGroup<'p> {
             }
             (Self::Transform(group), UniRule::Transform(rule)) => {
                 // we receive rules via `push` in source-order, which is the opposite order we want,
-                // so we push_back.
-                group.push_back(rule);
+                // so we push_front.
+                group.push_front(rule);
                 None
             }
             (Self::Conversion(_), UniRule::Transform(new_rule)) => {