make ?,n merge adjacent ?s (#806)

* merge ?s into adjacent ?,n

* document ?,n merging ?s

* document ?,n merging ?s in /docs/stack

Author: lemonlime4

changelog.md

@@ -45,6 +45,7 @@ This version is not yet released. If you are reading this on the website, then t
   - [`un °`](https://uiua.org/docs/un)[`&cd`](https://uiua.org/docs/&cd) will output the current working directory
   - [`under ⍜`](https://uiua.org/docs/under)[`&cd`](https://uiua.org/docs/&cd) will return to the original directory afterward
 - Add experimental [`reciprocal ⨪`](https://uiua.org/docs/reciprocal) function, which computes the multiplicative inverse AKA reciprocal of a number
+- Make subscripted [`stack ?`](https://uiua.org/docs/stack) merge adjacent non-subscripted [`stack ?`](https://uiua.org/docs/stack) chains
 ### Interpreter
 - Speed up the implementation of [`or ∨`](https://uiua.org/docs/or)
 - The fomatter no longer truncates trailing decimal `0`s from number literals

parser/src/defs.rs

@@ -2923,7 +2923,10 @@ primitive!(
     /// Subscripted [stack] prints that many values from the stack.
     /// ex: ?₂ 1 2 3 4
     /// If you type `N+1` `?`s, it will format to [stack] subscripted with `N`.
-    /// ex: ??? 1 2 3 4 # Try formatting!
+    /// A subscripted `?` will merge adjacent `?s` into its subscript.
+    /// ex: # Try formatting!
+    ///   : ???? 1 2 3 4
+    ///   : ?₂?? 5 6 7 8
     (0(0), Stack, Debug, ("stack", '?'), Mutating),
     /// Preprocess and print all stack values without popping them
     ///

parser/src/lex.rs

@@ -1118,13 +1118,68 @@ impl<'a> Lexer<'a> {
                 // Stack
                 "?" => {
                     self.end(Primitive::Stack, start);
-                    let mut n = 0;
                     let start = self.loc;
-                    while self.next_char_exact("?") {
-                        n += 1;
+
+                    fn read_chain(lexer: &mut Lexer) -> (i32, Loc) {
+                        let mut n = 0;
+                        let mut before_last = lexer.loc;
+                        loop {
+                            let start = lexer.loc;
+                            if lexer.next_char_exact("?") {
+                                n += 1;
+                                if lexer.peek_char() != Some("?") {
+                                    before_last = start;
+                                    break;
+                                }
+                            } else {
+                                break;
+                            }
+                        }
+                        (n, before_last)
                     }
-                    if n > 0 {
-                        self.end(Subscr(Subscript::numeric(n)), start);
+
+                    let (n, before_last_in_chain) = read_chain(&mut self);
+
+                    let subscript = {
+                        if self.next_char_exact(",") || self.next_chars_exact(["_"; 2]) {
+                            Some(self.subscript(","))
+                        } else if self.peek_char().map_or(false, is_formatted_subscript) {
+                            let init = self.next_char().unwrap();
+                            Some(self.subscript(init))
+                        } else {
+                            None
+                        }
+                    };
+                    match subscript {
+                        Some(Subscript {
+                            num: Some(NumericSubscript::N(num)),
+                            side: None,
+                        }) => {
+                            let (m, before_last_2nd_chain) = read_chain(&mut self);
+                            let has_2nd_subscript = self.next_char_exact(",")
+                                || self.next_chars_exact(["_"; 2])
+                                || self.peek_char().map_or(false, is_formatted_subscript);
+                            if !has_2nd_subscript {
+                                self.end(Subscr(Subscript::numeric(n + num + m)), start);
+                            } else {
+                                let sub_num = n + num + (m - 1).max(0);
+                                self.loc = before_last_2nd_chain;
+                                self.end(Subscr(Subscript::numeric(sub_num)), start);
+                            }
+                        }
+                        Some(_) => {
+                            // invalid subscript
+                            self.loc = before_last_in_chain;
+                            if n > 1 {
+                                self.end(Subscr(Subscript::numeric(n - 1)), start);
+                            }
+                        }
+                        None => {
+                            // no subscript
+                            if n != 0 {
+                                self.end(Subscr(Subscript::numeric(n)), start);
+                            }
+                        }
                     }
                 }
                 // Comments
@@ -1263,7 +1318,7 @@ impl<'a> Lexer<'a> {
                     }
                 }
                 // Formatted subscripts
-                c if "₋⌞⌟".contains(c) || c.chars().all(|c| SUBSCRIPT_DIGITS.contains(&c)) => {
+                c if is_formatted_subscript(c) => {
                     let sub = self.subscript(c);
                     self.end(Subscr(sub), start)
                 }
@@ -1706,6 +1761,10 @@ pub fn is_custom_glyph(c: &str) -> bool {
     }
 }
 
+fn is_formatted_subscript(c: &str) -> bool {
+    "₋⌞⌟".contains(c) || c.chars().all(|c| SUBSCRIPT_DIGITS.contains(&c))
+}
+
 pub(crate) fn canonicalize_ident(ident: &str) -> Ident {
     canonicalize_subscripts(canonicalize_exclams(ident))
 }