`4afec87`

Improve function parsing in structured input and expand help modal

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 4afec8778e25545d5f580f6baf8a58c17c95063b
Parents: c2468a1
Tree: 1b72c81

3 changed files

Status	File	+	-
M	`garcalc-math/src/convert.rs`	254	22
M	`garcalc-math/src/input.rs`	160	2
M	`garcalc/src/ui.rs`	161	58

garcalc-math/src/convert.rsmodified

          return to_expr(&items[0]);
+     }
 -    // Simple parsing: collect operands and operators
 +    // Parse a flat row with implicit multiplication and basic precedence.
      let mut operands: Vec<Expr> = Vec::new();
      let mut operators: Vec<Operator> = Vec::new();
 +    let mut expecting_operand = true;
      let mut i = 0;
      while i < items.len() {
 -        match &items[i] {
 -            MathBox::Operator(op) => {
 -                operators.push(*op);
 +        let mut push_operand = |expr: Expr| {
 +            if !expecting_operand {
 +                operators.push(Operator::Mul);
+             }
 -            MathBox::Symbol(s) if s == "!" => {
 +            operands.push(expr);
 +            expecting_operand = false;
 +        };
++
 +        match (&items[i], items.get(i + 1)) {
 +            (MathBox::Operator(op), _) => {
 +                match op {
 +                    Operator::Add if expecting_operand => {
 +                        // Unary plus: no-op.
 +                    }
 +                    Operator::Sub if expecting_operand => {
 +                        // Unary minus: rewrite as 0 - ...
 +                        operands.push(Expr::Integer(0));
 +                        operators.push(Operator::Sub);
 +                    }
 +                    _ => {
 +                        operators.push(*op);
 +                    }
 +                }
 +                expecting_operand = true;
 +            }
 +            (MathBox::Symbol(s), _) if s == "!" => {
                  let Some(last) = operands.pop() else {
                      return Err(ConvertError::MissingField(
                          "factorial operand before '!'".to_string(),
                      ));
                  };
                  operands.push(Expr::Func("factorial".to_string(), vec![last]));
 +                expecting_operand = false;
+             }
 -            other => {
 -                operands.push(to_expr(other)?);
 +            (MathBox::Symbol(name), Some(MathBox::Parens(inner)))
 +                if is_function_name(name.as_str()) =>
 +            {
 +                let args = parse_paren_args(inner)?;
 +                push_operand(Expr::Func(name.clone(), args));
 +                i += 1; // Consume the following parens node.
 +            }
 +            (other, _) => {
 +                push_operand(to_expr(other)?);
+             }
+         }
          i += 1;
+     }
 -    // Simple left-to-right evaluation (no precedence for now)
      if operands.is_empty() {
          return Err(ConvertError::EmptySlot);
+     }
 +    // If there are adjacent operands but no explicit operators, treat as multiplication.
 +    if operators.is_empty() {
 +        return if operands.len() == 1 {
 +            Ok(operands.pop().unwrap())
 +        } else {
 +            Ok(Expr::Mul(operands))
 +        };
 +    }
++
 +    // Maintain operand/operator alignment by appending implicit multiplications
 +    // when needed due malformed rows.
 +    while operators.len() + 1 < operands.len() {
 +        operators.push(Operator::Mul);
 +    }
++
 +    if operators.len() + 1 != operands.len() {
 +        return Err(ConvertError::Unsupported);
 +    }
++
 +    // First pass: *, /
 +    let mut idx = 0;
 +    while idx < operators.len() {
 +        match operators[idx] {
 +            Operator::Mul | Operator::Div => {
 +                let lhs = operands[idx].clone();
 +                let rhs = operands[idx + 1].clone();
 +                let merged = match operators[idx] {
 +                    Operator::Mul => Expr::Mul(vec![lhs, rhs]),
 +                    Operator::Div => Expr::Mul(vec![
 +                        lhs,
 +                        Expr::Pow(Box::new(rhs), Box::new(Expr::Integer(-1))),
 +                    ]),
 +                    _ => unreachable!(),
 +                };
 +                operands[idx] = merged;
 +                operands.remove(idx + 1);
 +                operators.remove(idx);
 +            }
 +            _ => idx += 1,
 +        }
 +    }
++
 +    // Second pass: +, -, =
      let mut result = operands[0].clone();
      for (i, op) in operators.iter().enumerate() {
 -        if i + 1 < operands.len() {
 -            let rhs = operands[i + 1].clone();
 -            result = match op {
 -                Operator::Add => Expr::Add(vec![result, rhs]),
 -                Operator::Sub => Expr::Add(vec![result, Expr::Neg(Box::new(rhs))]),
 -                Operator::Mul => Expr::Mul(vec![result, rhs]),
 -                Operator::Div => Expr::Mul(vec![
 -                    result,
 -                    Expr::Pow(Box::new(rhs), Box::new(Expr::Integer(-1))),
 -                ]),
 -                Operator::Eq => Expr::Equation(Box::new(result), Box::new(rhs)),
 -                _ => result, // Ignore comparison operators for now
 -            };
 -        }
 +        let rhs = operands[i + 1].clone();
 +        result = match op {
 +            Operator::Add => Expr::Add(vec![result, rhs]),
 +            Operator::Sub => Expr::Add(vec![result, Expr::Neg(Box::new(rhs))]),
 +            Operator::Eq => Expr::Equation(Box::new(result), Box::new(rhs)),
 +            Operator::Lt => Expr::Inequality {
 +                lhs: Box::new(result),
 +                op: garcalc_cas::expr::InequalityOp::Lt,
 +                rhs: Box::new(rhs),
 +            },
 +            Operator::Gt => Expr::Inequality {
 +                lhs: Box::new(result),
 +                op: garcalc_cas::expr::InequalityOp::Gt,
 +                rhs: Box::new(rhs),
 +            },
 +            Operator::Le => Expr::Inequality {
 +                lhs: Box::new(result),
 +                op: garcalc_cas::expr::InequalityOp::Le,
 +                rhs: Box::new(rhs),
 +            },
 +            Operator::Ge => Expr::Inequality {
 +                lhs: Box::new(result),
 +                op: garcalc_cas::expr::InequalityOp::Ge,
 +                rhs: Box::new(rhs),
 +            },
 +            Operator::Ne => Expr::Inequality {
 +                lhs: Box::new(result),
 +                op: garcalc_cas::expr::InequalityOp::Ne,
 +                rhs: Box::new(rhs),
 +            },
 +            Operator::Mul | Operator::Div | Operator::Comma => {
 +                return Err(ConvertError::Unsupported);
 +            }
 +        };
+     }
      Ok(result)
+ }
 +fn parse_paren_args(inner: &MathBox) -> Result<Vec<Expr>, ConvertError> {
 +    match inner {
 +        MathBox::Row(items) => {
 +            let mut args = Vec::new();
 +            let mut current = Vec::new();
++
 +            for item in items {
 +                if matches!(item, MathBox::Operator(Operator::Comma)) {
 +                    if current.is_empty() {
 +                        return Err(ConvertError::MissingField(
 +                            "function argument before comma".to_string(),
 +                        ));
 +                    }
 +                    args.push(to_expr(&MathBox::Row(std::mem::take(&mut current)))?);
 +                } else {
 +                    current.push(item.clone());
 +                }
 +            }
++
 +            if current.is_empty() && args.is_empty() {
 +                return Err(ConvertError::EmptySlot);
 +            }
 +            if !current.is_empty() {
 +                args.push(to_expr(&MathBox::Row(current))?);
 +            }
++
 +            Ok(args)
 +        }
 +        _ => Ok(vec![to_expr(inner)?]),
 +    }
 +}
++
 +fn is_function_name(name: &str) -> bool {
 +    matches!(
 +        name,
 +        "sin"
 +            | "cos"
 +            | "tan"
 +            | "cot"
 +            | "sec"
 +            | "csc"
 +            | "asin"
 +            | "acos"
 +            | "atan"
 +            | "sinh"
 +            | "cosh"
 +            | "tanh"
 +            | "asinh"
 +            | "acosh"
 +            | "atanh"
 +            | "ln"
 +            | "log"
 +            | "log10"
 +            | "log2"
 +            | "exp"
 +            | "sqrt"
 +            | "cbrt"
 +            | "abs"
 +            | "floor"
 +            | "ceil"
 +            | "round"
 +            | "trunc"
 +            | "sign"
 +            | "gamma"
 +            | "factorial"
 +            | "diff"
 +            | "derivative"
 +            | "integrate"
 +            | "integral"
 +            | "limit"
 +            | "lim"
 +            | "solve"
 +            | "sum"
 +            | "product"
 +            | "prod"
 +            | "simplify"
 +            | "expand"
 +            | "factor"
 +            | "substitute"
 +            | "subs"
 +            | "min"
 +            | "max"
 +            | "gcd"
 +            | "lcm"
 +            | "det"
 +            | "determinant"
 +            | "inv"
 +            | "inverse"
 +            | "transpose"
 +            | "trace"
 +            | "matmul"
 +            | "identity"
 +    )
 +}
++
  fn format_float(f: f64) -> String {
      if f == f.trunc() && f.abs() < 1e15 {
          format!("{:.0}", f)
          );
+     }
 +    #[test]
 +    fn test_row_implicit_multiplication_converts_to_mul() {
 +        let mb = MathBox::Row(vec![
 +            MathBox::Number("2".to_string()),
 +            MathBox::Symbol("x".to_string()),
 +        ]);
++
 +        let expr = to_expr(&mb).unwrap();
 +        assert_eq!(
 +            expr,
 +            Expr::Mul(vec![Expr::Integer(2), Expr::Symbol(Symbol::new("x"))])
 +        );
 +    }
++
 +    #[test]
 +    fn test_row_symbol_parens_known_function_converts_to_func() {
 +        let mb = MathBox::Row(vec![
 +            MathBox::Symbol("sin".to_string()),
 +            MathBox::Parens(Box::new(MathBox::Symbol("x".to_string()))),
 +        ]);
++
 +        let expr = to_expr(&mb).unwrap();
 +        assert_eq!(
 +            expr,
 +            Expr::Func("sin".to_string(), vec![Expr::Symbol(Symbol::new("x"))])
 +        );
 +    }
++
 +    #[test]
 +    fn test_row_symbol_parens_unknown_name_stays_multiplication() {
 +        let mb = MathBox::Row(vec![
 +            MathBox::Symbol("f".to_string()),
 +            MathBox::Parens(Box::new(MathBox::Symbol("x".to_string()))),
 +        ]);
++
 +        let expr = to_expr(&mb).unwrap();
 +        assert_eq!(
 +            expr,
 +            Expr::Mul(vec![
 +                Expr::Symbol(Symbol::new("f")),
 +                Expr::Symbol(Symbol::new("x"))
 +            ])
 +        );
 +    }
++
      #[test]
      fn test_from_expr_fraction_drops_unity_factor_in_numerator() {
          let expr = Expr::Mul(vec![

garcalc-math/src/input.rsmodified

                  InputResult::Consumed
+             }
              '(' => {
 -                self.insert_at_cursor(MathBox::Parens(Box::new(MathBox::Slot)));
 -                self.cursor.enter(0);
 +                if !self.wrap_current_symbol_as_function_call() {
 +                    self.insert_at_cursor(MathBox::Parens(Box::new(MathBox::Slot)));
 +                    self.cursor.enter(0);
 +                }
                  InputResult::Consumed
+             }
              ')' => {
          false
+     }
 +    fn wrap_current_symbol_as_function_call(&mut self) -> bool {
 +        let path = self.cursor.path.clone();
 +        let symbol_name = match Self::get_node_at_path(&self.root, &path) {
 +            Some(MathBox::Symbol(name)) => name.clone(),
 +            _ => return false,
 +        };
++
 +        let normalized = symbol_name.to_ascii_lowercase();
 +        if !Self::is_known_function_name(&normalized) {
 +            return false;
 +        }
++
 +        if let Some(node) = Self::get_node_mut_at_path(&mut self.root, &path) {
 +            *node = MathBox::Func {
 +                name: normalized,
 +                args: vec![MathBox::Slot],
 +            };
 +            self.cursor.enter(0);
 +            self.cursor.offset = 0;
 +            true
 +        } else {
 +            false
 +        }
 +    }
++
 +    fn is_known_function_name(name: &str) -> bool {
 +        matches!(
 +            name,
 +            "sin"
 +                | "cos"
 +                | "tan"
 +                | "cot"
 +                | "sec"
 +                | "csc"
 +                | "asin"
 +                | "acos"
 +                | "atan"
 +                | "sinh"
 +                | "cosh"
 +                | "tanh"
 +                | "asinh"
 +                | "acosh"
 +                | "atanh"
 +                | "ln"
 +                | "log"
 +                | "log10"
 +                | "log2"
 +                | "exp"
 +                | "sqrt"
 +                | "cbrt"
 +                | "abs"
 +                | "floor"
 +                | "ceil"
 +                | "round"
 +                | "trunc"
 +                | "sign"
 +                | "gamma"
 +                | "factorial"
 +                | "diff"
 +                | "derivative"
 +                | "integrate"
 +                | "integral"
 +                | "limit"
 +                | "lim"
 +                | "solve"
 +                | "sum"
 +                | "product"
 +                | "prod"
 +                | "simplify"
 +                | "expand"
 +                | "factor"
 +                | "substitute"
 +                | "subs"
 +                | "min"
 +                | "max"
 +                | "gcd"
 +                | "lcm"
 +                | "det"
 +                | "determinant"
 +                | "inv"
 +                | "inverse"
 +                | "transpose"
 +                | "trace"
 +                | "matmul"
 +                | "identity"
 +        )
 +    }
++
      /// Try to exit current container (parens, etc.)
      fn try_exit_container(&mut self) {
          if !self.cursor.is_at_root() {
          assert!(rendered.contains(", x, 0, 1)"), "rendered: {rendered}");
+     }
 +    #[test]
 +    fn test_integral_body_typed_function_parses_as_function_call() {
 +        let mut input = MathInput::new();
 +        run_command(&mut input, "int");
++
 +        input.handle_char('s');
 +        input.handle_char('i');
 +        input.handle_char('n');
 +        input.handle_char('(');
 +        input.handle_char('x');
 +        input.handle_char(')');
++
 +        let expr = to_expr(input.mathbox()).expect("structured input should convert");
 +        assert_eq!(expr.to_string(), "integrate(sin(x), x)");
 +    }
++
      #[test]
      fn test_diff_focus_and_tab_order_var_body() {
          let mut input = MathInput::new();
          assert_eq!(input.cursor_path(), &[0]);
+     }
 +    #[test]
 +    fn test_open_paren_after_function_name_wraps_as_func() {
 +        let mut input = MathInput::new();
 +        input.handle_char('s');
 +        input.handle_char('i');
 +        input.handle_char('n');
 +        input.handle_char('(');
++
 +        assert_eq!(input.cursor_path(), &[0, 0]);
 +        if let MathBox::Row(items) = &input.root {
 +            if let MathBox::Func { name, args } = &items[0] {
 +                assert_eq!(name, "sin");
 +                assert_eq!(args.len(), 1);
 +                assert!(matches!(&args[0], MathBox::Slot));
 +            } else {
 +                panic!("Expected function call");
 +            }
 +        } else {
 +            panic!("Expected row root");
 +        }
 +    }
++
 +    #[test]
 +    fn test_open_paren_after_non_function_symbol_keeps_parens() {
 +        let mut input = MathInput::new();
 +        input.handle_char('f');
 +        input.handle_char('(');
++
 +        assert_eq!(input.cursor_path(), &[1, 0]);
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Symbol(s) if s == "f"));
 +            assert!(matches!(&items[1], MathBox::Parens(_)));
 +        } else {
 +            panic!("Expected row root");
 +        }
 +    }
++
 +    #[test]
 +    fn test_open_paren_after_mixed_case_function_normalizes_name() {
 +        let mut input = MathInput::new();
 +        input.handle_char('S');
 +        input.handle_char('i');
 +        input.handle_char('N');
 +        input.handle_char('(');
++
 +        if let MathBox::Row(items) = &input.root {
 +            assert!(matches!(&items[0], MathBox::Func { name, .. } if name == "sin"));
 +        } else {
 +            panic!("Expected row root");
 +        }
 +    }
++
      #[test]
      fn test_backspace_at_exponent_start_deletes_base() {
          let mut input = MathInput::new();

garcalc/src/ui.rsmodified

      fn help_modal_rect(&self) -> Rect {
          let size = self.renderer.size();
 -        let width = ((size.width as f64 * 0.72).clamp(460.0, 760.0)).round() as u32;
 -        let height = ((size.height as f64 * 0.74).clamp(360.0, 560.0)).round() as u32;
 +        let width = ((size.width as f64 * 0.82).clamp(520.0, 920.0)).round() as u32;
 +        let height = ((size.height as f64 * 0.82).clamp(420.0, 700.0)).round() as u32;
          Rect::new(
              ((size.width - width) / 2) as i32,
              ((size.height - height) / 2) as i32,
              &title_style,
          )?;
 +        let sub_style = TextStyle::new()
 +            .font_family(&self.theme.font_family)
 +            .font_size(11.0)
 +            .color(self.theme.foreground.with_alpha(0.75));
 +        self.renderer.text(
 +            "Shortcuts, structured math input, and mode controls",
 +            (modal.x + 20) as f64,
 +            (modal.y + 36) as f64,
 +            &sub_style,
 +        )?;
++
          let heading_style = TextStyle::new()
              .font_family(&self.theme.font_family)
              .font_size(13.0)
              .color(self.theme.selection_foreground);
          let body_style = TextStyle::new()
              .font_family(&self.theme.font_family)
 -            .font_size(12.0)
 +            .font_size(11.5)
              .color(self.theme.foreground.with_alpha(0.92));
          let hint_style = TextStyle::new()
              .font_family(&self.theme.font_family)
              .font_size(11.0)
              .color(self.theme.foreground.with_alpha(0.75));
 -        let mut y = modal.y + 48;
 -        let x = modal.x + 20;
+-
 +        let content_top = modal.y + 56;
 +        let content_left = modal.x + 20;
 +        let content_width = modal.width as i32 - 40;
 +        let column_gap = 24;
 +        let column_width = (content_width - column_gap) / 2;
 +        let left_x = content_left;
 +        let right_x = content_left + column_width + column_gap;
 +        let divider_x = content_left + column_width + (column_gap / 2);
 +        let divider_rect = Rect::new(
 +            divider_x,
 +            content_top + 2,
 +            1,
 +            modal.height.saturating_sub(94),
 +        );
          self.renderer
 -            .text("Common expressions", x as f64, y as f64, &heading_style)?;
 -        y += 22;
 -        for line in [
 -            "2+2, sin(pi/2), sqrt(2), x^2 + 2*x + 1",
 -            "diff(x^2, x), integrate(sin(x), x), solve(x^2-4, x)",
 -            "sum(k, k, 1, n), product(k, k, 1, n)",
 -        ] {
 -            self.renderer
 -                .text(&format!("- {line}"), x as f64, y as f64, &body_style)?;
 -            y += 18;
 -        }
+-
 -        y += 10;
 -        self.renderer.text(
 -            "Structured input commands",
 -            x as f64,
 -            y as f64,
 +            .fill_rect(divider_rect, self.theme.border.with_alpha(0.45))?;
++
 +        let mut left_y = content_top;
 +        let mut right_y = content_top;
++
 +        self.draw_help_section(
 +            left_x,
 +            &mut left_y,
 +            "Quick Start",
 +            &[
 +                "Enter evaluates the current expression.",
 +                "Esc clears input (or closes this help).",
 +                "Type '?' or click ? to toggle this panel.",
 +                "F1 calculator, F2 graph, F3 graph 3D.",
 +            ],
              &heading_style,
 +            &body_style,
 +        )?;
 +        left_y += 6;
++
 +        self.draw_help_section(
 +            left_x,
 +            &mut left_y,
 +            "Structured Templates",
 +            &[
 +                "Type '\\' or ':' then command + Space/Enter.",
 +                "\\frac \\sqrt \\nthroot \\abs \\matrix",
 +                "\\sum \\prod \\int \\dint \\lim \\diff",
 +                "\\solve \\sin \\cos \\tan \\ln \\exp",
 +                "Tab / Shift+Tab moves between template slots.",
 +            ],
 +            &heading_style,
 +            &body_style,
 +        )?;
 +        left_y += 6;
++
 +        self.draw_help_section(
 +            left_x,
 +            &mut left_y,
 +            "Editing And History",
 +            &[
 +                "Arrow keys move inside boxes and fractions.",
 +                "Backspace/Delete remove chars or empty boxes.",
 +                "Home/End jumps to start/end of input.",
 +                "Use '^', '_', '/', '!' for power/sub/frac/factorial.",
 +                "Up/Down on blank input recalls history.",
 +                "Ctrl+Up/Down forces history browsing.",
 +            ],
 +            &heading_style,
 +            &body_style,
          )?;
 -        y += 22;
 -        for line in [
 -            "Type '\\' then command and press Enter/Space.",
 -            "\\frac  \\sqrt  \\sum  \\prod  \\diff  \\dint  \\lim  \\solve",
 -        ] {
 -            self.renderer
 -                .text(&format!("- {line}"), x as f64, y as f64, &body_style)?;
 -            y += 18;
 -        }
 -        y += 10;
 -        self.renderer
 -            .text("Keybinds", x as f64, y as f64, &heading_style)?;
 -        y += 22;
 -        for line in [
 -            "Enter evaluate, Tab/Shift+Tab move slot focus",
 -            "Arrow keys move cursor, Up/Down recall history when input is blank",
 -            "Ctrl+Up/Down force calculator history recall",
 -            "F1 calculator, F2 graph, F3 3D, Esc closes this help",
 -        ] {
 -            self.renderer
 -                .text(&format!("- {line}"), x as f64, y as f64, &body_style)?;
 -            y += 18;
 -        }
 +        self.draw_help_section(
 +            right_x,
 +            &mut right_y,
 +            "Calculator Examples",
 +            &[
 +                "2+2",
 +                "diff(x^2, x)",
 +                "integrate(sin(x), x)",
 +                "sum(k^2+k, k, 1, n)",
 +                "solve(x^2-4, x)",
 +            ],
 +            &heading_style,
 +            &body_style,
 +        )?;
 +        right_y += 6;
++
 +        self.draw_help_section(
 +            right_x,
 +            &mut right_y,
 +            "Graph Mode",
 +            &[
 +                "Enter y=... (or expression) to add a curve.",
 +                "Left-drag pans, mouse wheel zooms.",
 +                "Right-click toggles trace cursor.",
 +                "Ctrl+R reset view, Ctrl+C clear, Ctrl+T trace.",
 +            ],
 +            &heading_style,
 +            &body_style,
 +        )?;
 +        right_y += 6;
++
 +        self.draw_help_section(
 +            right_x,
 +            &mut right_y,
 +            "3D Mode",
 +            &[
 +                "Enter z=... (or expression) to add a surface.",
 +                "Left-drag rotates camera, mouse wheel zooms.",
 +                "Ctrl+R reset camera, Ctrl+C clear surfaces.",
 +                "Parametric surface: (x(u,v), y(u,v), z(u,v)).",
 +            ],
 +            &heading_style,
 +            &body_style,
 +        )?;
 +        right_y += 6;
++
 +        self.draw_help_section(
 +            right_x,
 +            &mut right_y,
 +            "Behavior Notes",
 +            &[
 +                "Pretty output renders many symbolic forms directly.",
 +                "Definite integrals with numeric bounds evaluate numerically.",
 +                "Hard symbolic forms may remain as integrate(...).",
 +                "Click outside modal (or x) to close.",
 +            ],
 +            &heading_style,
 +            &body_style,
 +        )?;
 -        y += 8;
          let mode_hint = match mode {
 -            Mode::Graph => "Graph mode: drag to pan, scroll to zoom, right-click trace toggle.",
 -            Mode::Graph3D => "3D mode: drag to rotate camera, scroll to zoom depth.",
 -            _ => "Calculator mode: use pretty templates, then evaluate with Enter.",
 +            Mode::Graph => "Active mode: Graph.",
 +            Mode::Graph3D => "Active mode: Graph 3D.",
 +            _ => "Active mode: Calculator.",
          };
 +        let hint_y = modal.bottom() - 24;
          self.renderer
 -            .text(mode_hint, x as f64, y as f64, &hint_style)?;
 -        y += 20;
 -        self.renderer.text(
 -            "Tip: click outside this panel (or x) to close.",
 -            x as f64,
 -            y as f64,
 -            &hint_style,
 -        )?;
 +            .text(mode_hint, (modal.x + 20) as f64, hint_y as f64, &hint_style)?;
++
 +        Ok(())
 +    }
 +    fn draw_help_section(
 +        &mut self,
 +        x: i32,
 +        y: &mut i32,
 +        heading: &str,
 +        lines: &[&str],
 +        heading_style: &TextStyle,
 +        body_style: &TextStyle,
 +    ) -> Result<()> {
 +        self.renderer
 +            .text(heading, x as f64, *y as f64, heading_style)?;
 +        *y += 20;
 +        for line in lines {
 +            self.renderer
 +                .text(&format!("- {line}"), x as f64, *y as f64, body_style)?;
 +            *y += 16;
 +        }
          Ok(())
+     }