diff --git a/pest/src/iterators/pair.rs b/pest/src/iterators/pair.rs
index 85fe297b..39ffc795 100644
--- a/pest/src/iterators/pair.rs
+++ b/pest/src/iterators/pair.rs
@@ -340,25 +340,29 @@ impl<R: RuleType> fmt::Debug for Pair<'_, R> {
 
 impl<R: RuleType> fmt::Display for Pair<'_, R> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let rule = self.as_rule();
-        let start = self.pos(self.start);
-        let end = self.pos(self.pair());
-        let mut pairs = self.clone().into_inner().peekable();
-
-        if pairs.peek().is_none() {
-            write!(f, "{:?}({}, {})", rule, start, end)
+        if f.alternate() {
+            let rule = self.as_rule();
+            let start = self.pos(self.start);
+            let end = self.pos(self.pair());
+            let mut pairs = self.clone().into_inner().peekable();
+
+            if pairs.peek().is_none() {
+                write!(f, "{:?}({}, {})", rule, start, end)
+            } else {
+                write!(
+                    f,
+                    "{:?}({}, {}, [{}])",
+                    rule,
+                    start,
+                    end,
+                    pairs
+                        .map(|pair| format!("{:#}", pair))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
         } else {
-            write!(
-                f,
-                "{:?}({}, {}, [{}])",
-                rule,
-                start,
-                end,
-                pairs
-                    .map(|pair| format!("{}", pair))
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            )
+            write!(f, "{}", self.as_str())
         }
     }
 }
@@ -408,6 +412,7 @@ impl<R: RuleType> ::serde::Serialize for Pair<'_, R> {
 
 #[cfg(test)]
 mod tests {
+    use crate::alloc::{borrow::ToOwned, format, string::ToString};
     use crate::macros::tests::*;
     use crate::parser::Parser;
 
@@ -459,4 +464,16 @@ mod tests {
 
         assert_eq!(input, pair.get_input());
     }
+    #[test]
+    fn pair_to_string_matches_as_str() {
+        let pair = AbcParser::parse(Rule::a, "abcde").unwrap().next().unwrap();
+
+        assert_eq!(pair.to_string(), pair.as_str().to_string());
+    }
+    #[test]
+    fn alternate_format() {
+        let pair = AbcParser::parse(Rule::a, "abcde").unwrap().next().unwrap();
+        assert_eq!(format!("{}", pair), "abc".to_owned());
+        assert_eq!(format!("{:#}", pair), "a(0, 3, [b(1, 2)])".to_owned());
+    }
 }
diff --git a/pest/src/iterators/pairs.rs b/pest/src/iterators/pairs.rs
index 74dae4a1..b6d1094b 100644
--- a/pest/src/iterators/pairs.rs
+++ b/pest/src/iterators/pairs.rs
@@ -465,14 +465,18 @@ impl<R: RuleType> fmt::Debug for Pairs<'_, R> {
 
 impl<R: RuleType> fmt::Display for Pairs<'_, R> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "[{}]",
-            self.clone()
-                .map(|pair| format!("{}", pair))
-                .collect::<Vec<_>>()
-                .join(", ")
-        )
+        let inner = self
+            .clone()
+            .map(|pair| {
+                if f.alternate() {
+                    format!("{pair:#}")
+                } else {
+                    format!("{pair}")
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        write!(f, "[{inner}]")
     }
 }
 
@@ -621,8 +625,9 @@ mod tests {
     fn pairs_display() {
         let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
 
+        assert_eq!(format!("{}", pairs), "[abc, e]".to_owned());
         assert_eq!(
-            format!("{}", pairs),
+            format!("{:#}", pairs),
             "[a(0, 3, [b(1, 2)]), c(4, 5)]".to_owned()
         );
     }