GNU bug report logs - #78586
TeX-make-inline

Previous Next

To reply to this bug, email your comments to 78586 AT debbugs.gnu.org.
There is no need to reopen the bug first.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: bug-auctex <at> gnu.org
Subject: TeX-make-inline
Date: Sun, 25 May 2025 16:01:50 +0200

Hi Arash and all,

We had discussed in an earlier thread (bug#78006) the possibility of
adding some of my editing commands to AUCTeX (as standalone commands,
without default binds).  We could start with this one, discussed a bit
in that thread:

--8<---------------cut here---------------start------------->8---
(defcustom TeX-make-inline-delims '("$" . "$")
  "Delimiters for `TeX-make-inline' to surround inline LaTeX math."
  :type '(radio (const :tag "Dollar ($...$)" ("$" . "$"))
                (const :tag "Paren (\\(...\\))" ("\\(" . "\\)"))
                (cons :tag "Custom delimiters"
                      (string :tag "Left") (string :tag "Right"))))

(defun TeX-make-inline ()
  "Convert LaTeX display math environment at point to inline math.
Removes the enclosing math environment (such as \\[...\\] or
\\begin{equation}...\\end{equation}).  Replaces it with inline math
surrounded by `TeX-make-inline-delims', fitting the result onto one
line.  Leaves any trailing punctuation outside the math delimiters."
  (interactive)
  (when (texmathp)
    (when (fboundp 'preview-clearout-at-point)
      (preview-clearout-at-point))
    (save-excursion
      (let* ((env (car texmathp-why))
             (pos (cdr texmathp-why))
             (delims TeX-make-inline-delims))
        (cond
         ((member env '("\\(" "$")))
         ((member env '("\\[" "$$"))
          (goto-char pos)
          (delete-char 2)
          (let ((start (point))
                (end-delim (if (equal env "\\[") "\\]" "$$")))
            (search-forward end-delim)
            (delete-char -2)
            (TeX-make-inline--finalize-region start (point) delims)))
         (t
          (goto-char pos)
          (kill-line)
          (let ((start (point)))
            (search-forward (concat "\\end{" env "}"))
            (beginning-of-line)
            (kill-line)
            (TeX-make-inline--finalize-region start (point) delims))))))))

(defun TeX-make-inline--finalize-region (start end delims)
  "Finalize the inline conversion from START to END using DELIMS."
  (save-restriction
    (narrow-to-region start end)
    (whitespace-cleanup)

    (goto-char (point-min))
    (let ((re
           (concat "\\(?:"
                   (mapconcat #'identity
                              (if (boundp 'reftex-label-regexps)
                                  reftex-label-regexps
                                '("\\\\label{[^}]*"))
                              "\\|")
                   "\\)")))
      (while (re-search-forward re nil t)
        (replace-match "")))

    (goto-char (point-min))
    (while (looking-at "\\s-*$")
      (delete-line))
    (beginning-of-line-text)
    (delete-region (point-min) (point))

    (goto-char (point-max))
    (while (and (> (point) (point-min))
                (progn (forward-line -1)
                       (looking-at "\\s-*$")))
      (delete-line))
    (end-of-line)
    (skip-chars-backward " \t")
    (delete-region (point) (point-max))

    (goto-char (point-min))
    (insert (car delims))
    (goto-char (point-max))
    (insert "\n")
    (backward-char)

    (while (looking-back "[.,;:!?]" 5)
      (backward-char))
    (insert (cdr delims))

    (while (> (count-lines (point-min) (point-max)) 1)
      (join-line))))
--8<---------------cut here---------------end--------------->8---

I haven't prepared this as a patch because I'm not sure where to put it
or where to document it.  I looked around, and couldn't find a natural
place.  If no better idea comes to mind, then perhaps some new
"miscellaneous commands" section of latex.el, with a corresponding
section in the manual?  For what it's worth, there are a couple of other
editing-related commands I'd be inclined to propose.

Any feedback welcome.

Thanks, best,

Paul

Message #8 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Arash Esbati <arash <at> gnu.org>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Tue, 27 May 2025 14:57:56 +0200

Hi Paul,

"Paul D. Nelson" <ultrono <at> gmail.com> writes:

> We had discussed in an earlier thread (bug#78006) the possibility of
> adding some of my editing commands to AUCTeX (as standalone commands,
> without default binds).

Thanks for sharing.  I have some comments below:

> We could start with this one, discussed a bit in that thread:
>
> (defcustom TeX-make-inline-delims '("$" . "$")
>   "Delimiters for `TeX-make-inline' to surround inline LaTeX math."
>   :type '(radio (const :tag "Dollar ($...$)" ("$" . "$"))
>                 (const :tag "Paren (\\(...\\))" ("\\(" . "\\)"))
>                 (cons :tag "Custom delimiters"
>                       (string :tag "Left") (string :tag "Right"))))

Do we really need this?  Can we just take the value of
`TeX-electric-math', and make an assumption if it's nil?

> (defun TeX-make-inline ()

This function is LaTeX centric, right?  So I would call is
`LaTeX-make-inline-math' or something and put it in latex.el.

>   "Convert LaTeX display math environment at point to inline math.
> Removes the enclosing math environment (such as \\[...\\] or
> \\begin{equation}...\\end{equation}).  Replaces it with inline math
> surrounded by `TeX-make-inline-delims',

surrounded by `TeX-electric-math' if non-nil, or \"$..$\",

> fitting the result onto one
> line.  Leaves any trailing punctuation outside the math delimiters."
>   (interactive)
>   (when (texmathp)
>     (when (fboundp 'preview-clearout-at-point)
>       (preview-clearout-at-point))
>     (save-excursion
>       (let* ((env (car texmathp-why))
>              (pos (cdr texmathp-why))
>              (delims TeX-make-inline-delims))

(delims (or TeX-electric-math '("$" . "$")))

>         (cond
>          ((member env '("\\(" "$")))
>          ((member env '("\\[" "$$"))
>           (goto-char pos)
>           (delete-char 2)
>           (let ((start (point))
>                 (end-delim (if (equal env "\\[") "\\]" "$$")))
>             (search-forward end-delim)
>             (delete-char -2)
>             (TeX-make-inline--finalize-region start (point) delims)))
>          (t
>           (goto-char pos)
>           (kill-line)
>           (let ((start (point)))
>             (search-forward (concat "\\end{" env "}"))
>             (beginning-of-line)
>             (kill-line)
>             (TeX-make-inline--finalize-region start (point) delims))))))))
>
> (defun TeX-make-inline--finalize-region (start end delims)

(defun LaTeX--whatever-we-agree-to (...)

Would it be possible to write an ERT-test for feature?

> I haven't prepared this as a patch because I'm not sure where to put it
> or where to document it.  I looked around, and couldn't find a natural
> place.

I will have a look, will try to make a suggestion.

> For what it's worth, there are a couple of other editing-related
> commands I'd be inclined to propose.

👍

Best, Arash

Message #11 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Arash Esbati <arash <at> gnu.org>
Cc: 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Tue, 27 May 2025 16:58:58 +0200

[Message part 1 (text/plain, inline)]

Hi Arash, thanks for your feedback.  I put the updated draft at the end
of this message (to be converted into a patch once one of us thinks of a
good place to put it), and attach some tests.  Paul

[latex-make-inline-test.el (application/emacs-lisp, attachment)]

[Message part 3 (text/plain, inline)]

--8<---------------cut here---------------start------------->8---
(defun LaTeX-make-inline ()
  "Convert LaTeX display math environment at point to inline math.
Removes the enclosing math environment (such as \\[...\\] or
\\begin{equation}...\\end{equation}).  Replaces it with inline math
surrounded by surrounded by `TeX-electric-math' if non-nil, or \"$..$\",
fitting the result onto one line.  Leaves any trailing punctuation
outside the math delimiters."
  (interactive)
  (when (texmathp)
    (when (fboundp 'preview-clearout-at-point)
      (preview-clearout-at-point))
    (save-excursion
      (let* ((env (car texmathp-why))
             (pos (cdr texmathp-why))
             (delims (or TeX-electric-math '("$" . "$"))))
        (cond
         ((member env '("\\(" "$")))
         ((member env '("\\[" "$$"))
          (goto-char pos)
          (when (looking-back "\n[[:space:]]*")
            (forward-char 2)
            (save-excursion (join-line))
            (forward-char -2))
          (delete-char 2)
          (let ((start (point))
                (end-delim (if (equal env "\\[") "\\]" "$$")))
            (search-forward end-delim)
            (delete-char -2)
            (if (looking-back "\n[[:space:]]*")
                (goto-char (match-beginning 0)))
            (LaTeX--make-inline-finalize-region start (point) delims)))
         (t
          (goto-char pos)
          (kill-whole-line)
          (let ((start (point)))
            (search-forward (concat "\\end{" env "}"))
            (beginning-of-line)
            (kill-whole-line)
            (backward-char)
            (LaTeX--make-inline-finalize-region start (point) delims))))))))

(defun LaTeX--make-inline-finalize-region (start end delims)
  "Finalize the inline conversion from START to END using DELIMS."
  (save-restriction
    (narrow-to-region start end)

    (goto-char (point-min))
    (let ((re
           (concat "\\(?:"
                   (mapconcat #'identity
                              (if (boundp 'reftex-label-regexps)
                                  reftex-label-regexps
                                '("\\\\label{[^}]*"))
                              "\\|")
                   "\\)")))
      (while (re-search-forward re nil t)
        (replace-match "")))

    (goto-char (point-min))
    (while (looking-at "\\s-*$")
      (delete-line))
    (beginning-of-line-text)
    (delete-region (point-min) (point))

    (goto-char (point-max))
    (while (and (> (point) (point-min))
                (progn (forward-line -1)
                       (looking-at "\\s-*$")))
      (delete-line))
    (end-of-line)
    (skip-chars-backward " \t")
    (delete-region (point) (point-max))

    (goto-char (point-min))
    (insert (car delims))
    (goto-char (point-max))

    (while (looking-back "[.,;:!?]" (max (point-min) (- (point) 5)))
      (backward-char))
    (insert (cdr delims))

    (while (> (count-lines (point-min) (point-max)) 1)
      (join-line)))
  (join-line))
--8<---------------cut here---------------end--------------->8---

Message #14 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Arash Esbati <arash <at> gnu.org>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Thu, 29 May 2025 09:26:42 +0200

Hi Paul,

"Paul D. Nelson" <ultrono <at> gmail.com> writes:

> Hi Arash, thanks for your feedback.

You're welcome.

> I put the updated draft at the end of this message (to be converted
> into a patch once one of us thinks of a good place to put it), and
> attach some tests.

You said that you also have some other commands, right?  So I suggest we
put them at the end of latex.el, under ;; Utilities:.  WDYT?

Reg. manual: I suggest to document this command under

@subheading Dollar Signs

Maybe something like this:

--8<---------------cut here---------------start------------->8---
diff --git a/doc/auctex.texi b/doc/auctex.texi
index 0b486c8c..9602c062 100644
--- a/doc/auctex.texi
+++ b/doc/auctex.texi
@@ -484,6 +484,16 @@ to prevent unmatched dollar.
 Note that Texinfo mode does nothing special for @kbd{$}.  It inserts
 dollar sign(s) just in the same way as the other normal keys do.

+@AUCTeX{} provides the command @code{LaTeX-make-inline} which converts the
+display math environment at point to inline math.
+
+@deffn Command LaTeX-make-inline
+Convert @LaTeX{} display math environment at point to inline math.  This
+command replaces the enclosing math environment such as @samp{\[...\]} or
+@samp{\begin@{equation@}...\end@{equation@}} with the value of
+@code{TeX-electric-math} or @samp{$...$} by default.
+@end deffn
+
 @subheading Braces

 To avoid unbalanced braces, it is useful to insert them pairwise.  You
--8<---------------cut here---------------end--------------->8---


> (defun LaTeX-make-inline ()
>   "Convert LaTeX display math environment at point to inline math.
> Removes the enclosing math environment (such as \\[...\\] or
> \\begin{equation}...\\end{equation}).  Replaces it with inline math
> surrounded by surrounded by `TeX-electric-math' if non-nil, or \"$..$\",
> fitting the result onto one line.  Leaves any trailing punctuation
> outside the math delimiters."

Please use active voice, maybe something like this:

  "Convert LaTeX display math environment at point to inline math.
Remove the enclosing math environment (such as \\[...\\] or
\\begin{equation}...\\end{equation}) and replace it with inline math
surrounded by `TeX-electric-math' if non-nil, or \"$...$\",
fitting the result onto one line.  Finally, leave any trailing punctuation
outside the math delimiters."

>   (interactive)
>   (when (texmathp)
>     (when (fboundp 'preview-clearout-at-point)
>       (preview-clearout-at-point))
>     (save-excursion
>       (let* ((env (car texmathp-why))
>              (pos (cdr texmathp-why))
>              (delims (or TeX-electric-math '("$" . "$"))))

Why `let*'?

>         (cond
>          ((member env '("\\(" "$")))
>          ((member env '("\\[" "$$"))
>           (goto-char pos)
>           (when (looking-back "\n[[:space:]]*")
>             (forward-char 2)
>             (save-excursion (join-line))
>             (forward-char -2))
>           (delete-char 2)
>           (let ((start (point))
>                 (end-delim (if (equal env "\\[") "\\]" "$$")))
>             (search-forward end-delim)
>             (delete-char -2)
>             (if (looking-back "\n[[:space:]]*")
>                 (goto-char (match-beginning 0)))
>             (LaTeX--make-inline-finalize-region start (point) delims)))
>          (t
>           (goto-char pos)
>           (kill-whole-line)
>           (let ((start (point)))
>             (search-forward (concat "\\end{" env "}"))
>             (beginning-of-line)
>             (kill-whole-line)
>             (backward-char)
>             (LaTeX--make-inline-finalize-region start (point) delims))))))))
>
> (defun LaTeX--make-inline-finalize-region (start end delims)
>   "Finalize the inline conversion from START to END using DELIMS."
>   (save-restriction
>     (narrow-to-region start end)
>
>     (goto-char (point-min))
>     (let ((re
>            (concat "\\(?:"
>                    (mapconcat #'identity
>                               (if (boundp 'reftex-label-regexps)
>                                   reftex-label-regexps
>                                 '("\\\\label{[^}]*"))
>                               "\\|")
>                    "\\)")))

This looks somewhat easier to me:

(let ((re (concat "\\(?:"
                  (if (bound-and-true-p reftex-label-regexps)
                      (mapconcat #'identity reftex-label-regexps "\\|")
                    "\\\\label{[^}]*}")
                  "\\)")))

And note the missing '}' in "\\\\label{[^}]*".

Otherwise LGTM.

Best, Arash

Message #17 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Arash Esbati <arash <at> gnu.org>
Cc: 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Thu, 29 May 2025 11:15:58 +0200

[Message part 1 (text/plain, inline)]

Hi Arash,

Thanks again for your feedback, and sounds good on all counts.  Please
see attached.

Thanks, best,

Paul

[0001-Add-LaTeX-make-inline-command.patch (text/x-patch, attachment)]

Message #20 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Ikumi Keita <ikumi <at> ikumi.que.jp>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: Arash Esbati <arash <at> gnu.org>, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Fri, 30 May 2025 03:35:05 +0900

Hi Paul,

>>>>> "Paul D. Nelson" <ultrono <at> gmail.com> writes:
> Thanks again for your feedback, and sounds good on all counts.  Please
> see attached.

Thanks for your continuous contributions. I have a very minor comment
this time.

> +(defun LaTeX-make-inline ()
> +  "Convert LaTeX display math environment at point to inline math.
> +Remove the enclosing math environment (such as \\[...\\] or
                                                  ^^^

In docstrings, we need \= to escape \[ which introduces
command-to-keybind syntax 🙃

Bye,
Ikumi Keita
#StandWithUkraine #StopWarInUkraine
#Gaza #StopMassiveKilling #CeasefireNOW

Message #23 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Ikumi Keita <ikumi <at> ikumi.que.jp>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Thu, 29 May 2025 20:47:55 +0200

[Message part 1 (text/plain, inline)]

Thanks Ikuya, good catch!  Please find attached the updated patch.  Paul

[0001-Add-LaTeX-make-inline-command.patch (text/x-patch, attachment)]

Message #26 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Ikumi Keita <ikumi <at> ikumi.que.jp>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Fri, 30 May 2025 16:00:52 +0900

Hi Paul,

>>>>> "Paul D. Nelson" <ultrono <at> gmail.com> writes:
> Thanks Ikuya, good catch!  Please find attached the updated patch.  Paul

> +(defun LaTeX-make-inline ()
> +  "Convert LaTeX display math environment at point to inline math.
> +Remove the enclosing math environment (such as \\\\=[...\\\\=] or

That works but I recommend
\\=\\[
rather than \\\\=[ . See (elisp) Keys in Documentation:
,----
| ‘\=’
|      quotes the following character and is discarded; thus, ‘\=`’ puts
|      ‘`’ into the output, ‘\=\[’ puts ‘\[’ into the output, and ‘\=\=’
|      puts ‘\=’ into the output.
`----
And you don't have to quote \]. It will be displayed literally.

Additionally, we should provide similar quotation in
> +(ert-deftest LaTeX-make-inline-bracket-period ()
> +  "Convert \\[..\\] to $..$ and keep trailing period."
as well.

Bye,
Ikumi Keita
#StandWithUkraine #StopWarInUkraine
#Gaza #StopMassiveKilling #CeasefireNOW

Message #29 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Ikumi Keita <ikumi <at> ikumi.que.jp>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Sat, 31 May 2025 16:57:34 +0200

[Message part 1 (text/plain, inline)]

Hi Ikumi,

Thanks for the further feedback, which I've now incorporated.

I mentioned that this was the first of several commands I planned to
propose, in an attempt to upstream the most broadly useful stuff from
https://github.com/ultronozm/czm-tex-edit.el.

The next planned command was an "inverse" to LaTeX-make-inline, say
LaTeX-make-display, that converts inline math to display math.  I had
planned to propose that command in a separate bug, but the two are so
intertwined that I think it makes sense to treat them together.

The tricky part in designing LaTeX-make-display is that different users
may prefer different sorts of display math: \[..\], $$..$$,
equation/equation*/align/align*/(...).  Given that we don't want to add
too many new user options, it seemed best to provide a general
LaTeX-modify-math command, which the user can either invoke
interactively or specialize like so:

--8<---------------cut here---------------start------------->8---
(defun my-LaTeX-make-brackets ()
  "Convert math construct at point to \"\\=\\[..\\=\\]\"."
  (interactive)
  (LaTeX-modify-math "\\["))

(defun my-LaTeX-make-equation* ()
  "Convert math construct at point to \"equation*\"."
  (interactive)
  (LaTeX-modify-math "equation*"))

(defun my-LaTeX-toggle-numbered ()
  "Convert math construct at point to \"equation*\".
If the math construct is already \"equation*\", then toggle with the
numbered variant \"equation\"."
  (interactive)
  (unless (texmathp) (user-error "Not inside math"))
  (let ((current (car texmathp-why)))
    (LaTeX-modify-math
     (pcase current
       ("equation*" "equation")
       ("equation" "equation*")
       (_ "equation*")))))

(defun my-LaTeX-toggle-align ()
  "Toggle math environment at point between \"equation\" and \"align\"."
  (interactive)
  (unless (texmathp) (user-error "Not inside math"))
  (let ((current (car texmathp-why)))
    (LaTeX-modify-math
     (pcase current
       ("align*" "equation*")
       ("equation*" "align*")
       ("align" "equation")
       ("equation" "align")
       (_ "align*")))))
--8<---------------cut here---------------end--------------->8---

We could document some of these in the manual (where?), but leave their
precise implementation and binding to the user.

How does this plan sound?  The attached patch contains everything but
documentation concerning LaTeX-modify-math, for which I await feedback
on a location in the manual and the overall soundness of the approach.

Thanks, best,

Paul

[0001-Add-LaTeX-modify-math-and-LaTeX-make-inline.patch (text/x-patch, attachment)]

Message #32 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Ikumi Keita <ikumi <at> ikumi.que.jp>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Tue, 03 Jun 2025 04:24:27 +0900

Hi Paul,

>>>>> "Paul D. Nelson" <ultrono <at> gmail.com> writes:
> The next planned command was an "inverse" to LaTeX-make-inline, say
> LaTeX-make-display, that converts inline math to display math.  I had
> planned to propose that command in a separate bug, but the two are so
> intertwined that I think it makes sense to treat them together.

> The tricky part in designing LaTeX-make-display is that different users
> may prefer different sorts of display math: \[..\], $$..$$,
> equation/equation*/align/align*/(...).  Given that we don't want to add
> too many new user options, it seemed best to provide a general
> LaTeX-modify-math command, which the user can either invoke
> interactively or specialize like so:
> (defun my-LaTeX-make-brackets ()

[...]

> How does this plan sound?  The attached patch contains everything but
> documentation concerning LaTeX-modify-math, for which I await feedback
> on a location in the manual and the overall soundness of the approach.

It seems interesting to me. I remember Uwe Brauer once requested such
feature[1].

[1] https://lists.gnu.org/r/auctex-devel/2022-01/msg00010.html

Here are my comments about your proposal. (I haven't acutually run the
code, so I might be saying something very dumb, sorry):

+(defun LaTeX--modify-math-1 (open close inline new-open new-close new-inline pos)
+  "Helper function for `LaTeX-modify-math'.
+OPEN and CLOSE are the current delimiters, NEW-OPEN and NEW-CLOSE are
+the new delimiters.  INLINE and NEW-INLINE are booleans indicating
+whether the current and new delimiters are inline or display math.
+Assume point is at the start of the current OPEN delimiter.  POS is a
+marker that keeps track of cursor position."
+  (let ((converting-to-inline (and (not inline) new-inline)))
+    (when converting-to-inline
+      ;; Join with previous line if non-blank.
+      (when (and (looking-back "\n[[:blank:]]*" (point-min)) ... (1)
+                 (> (line-beginning-position) (point-min))   ... (2)
+                 (save-excursion
+                   (forward-line -1)
+                   (not (looking-at "^[[:blank:]]*$"))))

I'd write the conditional for the second `when' as
(save-excursion
  (skip-chars-backward "[:blank:]")
  (and 
    (bolp) (not (bobp))
    (progn
      (forward-char -1)
      (skip-chars-backward "[:blank:]")
      (not (bolp)))))
because `looking-back' isn't efficient. However, this piece of code
isn't as easy to read as yours, so you don't have to mind if you decide
to reject it.

Anyway, it seems to me that the condition (2) isn't needed because it is
always satisfied when the condition (1) is met, if I don't miss something.

+        (forward-char (length open))
+        (save-excursion (join-line))
+        (forward-char (- (length open)))))
+    (unless new-inline
+      ;; Ensure non-inline delimiters start on a blank line.
+      (unless (looking-back "\n[[:blank:]]*" (point-min))
+        (delete-horizontal-space)
+        (insert "\n")))
+    ;; Delete opening delimiter.
+    (delete-char (length open))
+    (let ((start (point)))
+      (search-forward close)
+      (when converting-to-inline
+        ;; Join with next line if non-blank.
+        (when (and (looking-at-p "[[:blank:]]*\n")
+                   (< (line-end-position) (point-max))  ... (3)
+                   (save-excursion
+                     (forward-line 1)
+                     (not (looking-at-p "^[[:blank:]]*$"))))

Again, the condition (3) seems dispensable.

+          (join-line 'next)))
+      (unless new-inline
+        (unless (looking-at-p "[[:blank:]]*\n")
+          (save-excursion
+            (insert "\n"))))
+      ;; Delete closing delimiter.
+      (delete-char (- (length close)))
+      (save-restriction
+        (narrow-to-region start (point))
+        ;; Clear labels.
+        (goto-char (point-min))
+        (let ((re (concat
+                   "\\(?:"
+                   (if (bound-and-true-p reftex-label-regexps)
+                       (mapconcat #'identity reftex-label-regexps "\\|")
+                     (format "%slabel%s%s%s"
+                             (regexp-quote TeX-esc)
+                             TeX-grop "[^}]*" TeX-grcl))
+                   "\\)")))
+          (while (re-search-forward re nil t)
+            (replace-match "")))
+        ;; Delete leading and trailing whitespace.

Is it really necessary to delete leading whitespaces? At the end of this
function, we do `indent-region', which I expect would do the job. (And
then, we can just call `delete-trailing-whitespace'.)

+        (dolist (re '("\\`[ \t\n\r]+" "[ \t\n\r]+\\'"))
+          (goto-char (point-min))
+          (when (re-search-forward re nil t)
+            (replace-match "")))

+        (unless new-inline
+          (goto-char (point-min))
+          (insert "\n")
+          (goto-char (point-max))
+          (insert "\n"))
+        ;; Insert new opening delimiter.
+        (goto-char (point-min))
+        (insert new-open)
+        ;; Insert new closing delimiter
+        (goto-char (point-max))
+        (when (eq (point) (marker-position pos))

We can simplify the conditional as
(= (point) pos)

+          (set-marker-insertion-type pos (not 'advance)))
+        (when converting-to-inline
+          ;; Leave punctuation outside.
+          (while (looking-back "[.,;:!?]"
+                               (max (point-min) (- (point) 5)))
+            (backward-char)))

We can use `skip-chars-backward' instead of the `while' loop.

+        (insert new-close)
+        ;; Indent, including one line past the modified region.
+        (widen)
+        (end-of-line 2)
+        (indent-region start (point))))))
+
+(defun LaTeX--closing (type)
+  "Return closing delimiter corresponding to given `texmathp' TYPE.
+TYPE must be one of the (La)TeX symbols $, $$, \\( or \\=\\[, or a valid
+environment name.  Macros such as \\ensuremath are not supported."
+  (pcase type
+    ((or "$" "$$") type)
+    ("\\[" "\\]")
+    ("\\(" "\\)")
+    (_ (unless (assoc type (LaTeX-environment-list-filtered))
+         (error "Invalid or unsupported opening delimiter: %s" type))
+       (concat TeX-esc "end" TeX-grop type TeX-grcl))))
+
+(defun LaTeX-modify-math (&optional new-type)

Why do you make the `new-type' argument optional? It is always non-nil
when called interactively, and must be non-nil when called in program
according to the following doc string.

+  "Modify the current math construct to NEW-TYPE.
+
+Interactively, prompt for NEW-TYPE from a list of inline math
+delimiters (\"$\", \"\\(\"), display math delimiters (\"$$\",
+\"\\=\\[\") and valid LaTeX environments (\"equation\", ...).
+
+Non-interactively, NEW-TYPE must be either
+- a string specifying the target delimiter or environment name, or
+- a cons cell ((OPEN . CLOSE) . INLINE), where OPEN and CLOSE are
+  delimiters and INLINE is non-nil if the math construct is to be
+  understood as inline.
+
+The function converts the math construct at point (inline, display, or
+environment) to the specified NEW-TYPE, preserving the content.  If
+point is not in a math construct, signal an error.  Clears any active
+previews at point before modification.
+
+Does not support modifying macro-based constructs such as \\ensuremath."
+  (interactive
+   (let* ((type (progn (texmathp) (car texmathp-why)))
+          (tbl (append '("$" "\\(" "$$" "\\[")
+                       (LaTeX-environment-list-filtered))))
+     (unless type (user-error "Not inside math"))
+     (LaTeX--closing type) ;; Check for errors.
+     (list (completing-read
+            (format "Convert %s → " type) tbl nil t nil nil
+            type))))
+  (let ((new-open (if (stringp new-type)
+                      new-type
+                    (caar new-type)))
+        (new-close (if (stringp new-type)
+                       (LaTeX--closing new-type)
+                     (cdar new-type)))
+        (new-inline (if (stringp new-type)
+                        (member new-type '("$" "\\("))
+                      (cdr new-type))))
+    (when (fboundp 'preview-clearout-at-point)
+      (preview-clearout-at-point))
+    (unless (called-interactively-p 'any)
+      (unless (texmathp) (error "Not inside math")))
+    (let ((type (car texmathp-why))
+          (math-start (cdr texmathp-why))
+          (pos (point-marker)))
+      (set-marker-insertion-type pos
+                                 (not
+                                  (and
+                                   (< (point) (point-max))
+                                   (save-excursion
+                                     (forward-char)
+                                     (not (texmathp))))))
+      (goto-char math-start)
+      (let* ((open (if (member type '("\\(" "$" "\\[" "$$"))
+                       type
+                     (concat TeX-esc "begin" TeX-grop type TeX-grcl)))
+             (close (LaTeX--closing type)))
+        (if (or (not (stringp new-type))
+                (member new-open '("$" "\\(" "\\[" "$$")))
+            ;; Conversion to inline or non-environment display.
+            (let* ((inline (member type '("$" "\\("))))
+              (LaTeX--modify-math-1 open close inline new-open new-close new-inline pos))
+          ;; Conversion to an environment.
+          (if (member type '("$" "\\(" "$$" "\\["))
+              (delete-char (length type))
+            (kill-line))
+          (push-mark (save-excursion
+                       (search-forward close)
+                       (delete-region (match-beginning 0) (match-end 0))
+                       (when (eq (point) (marker-position pos))

Again, we can do
(= (point) pos)
here.

+                         (setq pos nil))

I recommend to do
(set-marker pos nil)
before throwing away a temporal marker. See (elisp) Overview of Markers:
,----
| Insertion and deletion in a buffer must check all the markers and
| relocate them if necessary.  This slows processing in a buffer with a
| large number of markers.  For this reason, it is a good idea to make a
| marker point nowhere if you are sure you don't need it any more.
| Markers that can no longer be accessed are eventually removed (*note
| Garbage Collection::).
`----

+                       (when (member type '("$" "\\("))
+                         (while (looking-at-p "[.,;:!?]")
+                           (forward-char)))

Again, we can use `skip-chars-forward' here.

+                       (point)))
+          (activate-mark)
+          (LaTeX-insert-environment new-type)))
+      (when pos
+        (goto-char pos)))))

Again, I recommend to do
(set-marker pos nil)
when a temporal marker finishes its job.

+
+(defun LaTeX-make-inline ()
+  "Convert LaTeX display math construct at point to inline math.
+Remove the enclosing math construct (such as \\=\\[...\\=\\] or
+\\begin{equation}...\\end{equation}) and replace it with inline math
+surrounded by `TeX-electric-math' if non-nil, or \"$...$\", fitting the
+result onto one line.  Finally, leave any trailing punctuation outside
+the math delimiters."
+  (interactive)

How about
(interactive "*")
instead?
(Maybe we should consider to add
(barf-if-buffer-read-only)
in `LaTeX-modify-math' as well.)

+  (LaTeX-modify-math
+   (if TeX-electric-math
+       (cons TeX-electric-math 'inline)
+     "$")))
+

Regards,
Ikumi Keita
#StandWithUkraine #StopWarInUkraine
#Gaza #StopMassiveKilling #CeasefireNOW

Message #35 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Ikumi Keita <ikumi <at> ikumi.que.jp>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Tue, 03 Jun 2025 10:09:00 +0200

[Message part 1 (text/plain, inline)]

Hi Ikumi, many thanks for your feedback.

> Is it really necessary to delete leading whitespaces? At the end of this
> function, we do `indent-region', which I expect would do the job. (And
> then, we can just call `delete-trailing-whitespace'.)

Deleting whitespace is relevant when converting from display to inline.
It seemed like the appropriate way to handle the variety of ways users
might write display math, e.g., $$ x + y $$ with or without newlines.
Other suggestions would be welcome.

I've incorporated all the other suggested changes, together with the
following further changes:

- replaced calls to LaTeX-environment-list-filtered with a new helper
  function LaTeX-math-environment-list (which could be made internal, I
  suppose?) that returns a more suitable list.

- factored our a helper function LaTeX--strip-labels.

Any further feedback welcome.

Thanks, best,

Paul

[0001-Add-LaTeX-modify-math-and-LaTeX-make-inline.patch (text/x-patch, attachment)]

Message #38 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Ikumi Keita <ikumi <at> ikumi.que.jp>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Wed, 04 Jun 2025 18:44:11 +0900

Hi Paul,

>>>>> "Paul D. Nelson" <ultrono <at> gmail.com> writes:
> Deleting whitespace is relevant when converting from display to inline.
> It seemed like the appropriate way to handle the variety of ways users
> might write display math, e.g., $$ x + y $$ with or without newlines.

I see, thanks for explanation.

+(defun LaTeX--modify-math-1 (open close inline new-open new-close new-inline pos)
+  "Helper function for `LaTeX-modify-math'.
+OPEN and CLOSE are the current delimiters, NEW-OPEN and NEW-CLOSE are
+the new delimiters.  INLINE and NEW-INLINE are booleans indicating
+whether the current and new delimiters are inline or display math.
+Assume point is at the start of the current OPEN delimiter.  POS is a
+marker that keeps track of cursor position."
+  (let ((converting-to-inline (and (not inline) new-inline)))
+    (when converting-to-inline
+      ;; Join with previous line if non-blank.
+      (when (save-excursion
+              (skip-chars-backward "[:blank:]")
+              (and
+               (bolp) (not (bobp))
+               (progn
+                 (forward-char -1)
+                 (skip-chars-backward "[:blank:]")
+                 (not (bolp)))))
+        (forward-char (length open))
+        (save-excursion (join-line))
+        (forward-char (- (length open)))))

Why do you go forth and back here? What's wrong with a bare `join-line'
without two `forward-char's?

+(defun LaTeX-modify-math (new-type)
+  "Modify the current math construct to NEW-TYPE.
+
+Interactively, prompt for NEW-TYPE from a list of inline math
+delimiters (\"$\", \"\\(\"), display math delimiters (\"$$\",
+\"\\=\\[\") and valid LaTeX environments (\"equation\", ...).
+
+Non-interactively, NEW-TYPE must be either
+- a string specifying the target delimiter or environment name, or
+- a cons cell ((OPEN . CLOSE) . INLINE), where OPEN and CLOSE are
+  delimiters and INLINE is non-nil if the math construct is to be
+  understood as inline.
+
+The function converts the math construct at point (inline, display, or
+environment) to the specified NEW-TYPE, preserving the content.  If
+point is not in a math construct, signal an error.  Clears any active
+previews at point before modification.
+
+Does not support modifying macro-based constructs such as \\ensuremath."
+  (interactive
+   (let* ((type (progn (texmathp) (car texmathp-why)))
+          (tbl (append '("$" "\\(" "$$" "\\[")
+                       (LaTeX--math-environment-list))))
+     (barf-if-buffer-read-only)
+     (unless type (user-error "Not inside math"))
+     (LaTeX--closing type) ;; Check for errors.
+     (list (completing-read
+            (format "Convert %s → " type) tbl nil t nil nil
+            type))))
+  (let ((new-open (if (stringp new-type)
+                      new-type
+                    (caar new-type)))
+        (new-close (if (stringp new-type)
+                       (LaTeX--closing new-type)
+                     (cdar new-type)))
+        (new-inline (if (stringp new-type)
+                        (member new-type '("$" "\\("))
+                      (cdr new-type))))
+    (when (fboundp 'preview-clearout-at-point)
+      (preview-clearout-at-point))
+    (unless (called-interactively-p 'any)
+      (unless (texmathp) (error "Not inside math")))
+    (let ((type (car texmathp-why))
+          (math-start (cdr texmathp-why))
+          (pos (point-marker)))
+      (set-marker-insertion-type pos
+                                 (not
+                                  (and
+                                   (< (point) (point-max))
+                                   (save-excursion
+                                     (forward-char)
+                                     (not (texmathp))))))
+      (goto-char math-start)
+      (let* ((open (if (member type '("\\(" "$" "\\[" "$$"))
+                       type
+                     (concat TeX-esc "begin" TeX-grop type TeX-grcl)))
+             (close (LaTeX--closing type)))
+        (if (or (not (stringp new-type))
+                (member new-open '("$" "\\(" "\\[" "$$")))
+            ;; Conversion to inline or non-environment display.
+            (let* ((inline (member type '("$" "\\("))))
+              (LaTeX--modify-math-1 open close inline new-open new-close new-inline pos))
+          ;; Conversion to an environment.
+          (delete-char (length open))
+          (push-mark (save-excursion
+                       (search-forward close)
+                       (delete-region (match-beginning 0) (match-end 0))
+                       (when (= (point) pos)
+                         (set-marker pos nil))

We have to keep
(setq pos nil)
after `set-marker', which doesn't change the value of `pos' itself.

+                       (when (member type '("$" "\\("))
+                         (skip-chars-forward ".,;:!?"))
+                       (point)))
+          (activate-mark)
+          (LaTeX-insert-environment new-type)))
+      (when pos
+        (goto-char pos)
+        (set-marker pos nil)))))
+
+(defun LaTeX-make-inline ()
+  "Convert LaTeX display math construct at point to inline math.
+Remove the enclosing math construct (such as \\=\\[...\\=\\] or
+\\begin{equation}...\\end{equation}) and replace it with inline math
+surrounded by `TeX-electric-math' if non-nil, or \"$...$\", fitting the
+result onto one line.  Finally, leave any trailing punctuation outside
+the math delimiters."
+  (interactive "*")
+  (LaTeX-modify-math
+   (if TeX-electric-math
+       (cons TeX-electric-math 'inline)
+     "$")))

As far as I can see, the proposed feature doesn't support docTeX mode. I
don't think that is a practical problem at all, but addition of FIXME
comment and breif mention about it in the documentation would be nice.

Regards,
Ikumi Keita
#StandWithUkraine #StopWarInUkraine
#Gaza #StopMassiveKilling #CeasefireNOW

Message #41 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Ikumi Keita <ikumi <at> ikumi.que.jp>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Wed, 04 Jun 2025 12:22:19 +0200

[Message part 1 (text/plain, inline)]

Hi Ikumi,

> +        (forward-char (length open))
> +        (save-excursion (join-line))
> +        (forward-char (- (length open)))))
>
> Why do you go forth and back here? What's wrong with a bare `join-line'
> without two `forward-char's?

Suppose the buffer contains:

--8<---------------cut here---------------start------------->8---
We have
\begin{equation*}
  x + y = z.
\end{equation*}
--8<---------------cut here---------------end--------------->8---

With point on line 2, join-line yields a buffer with first line:

--8<---------------cut here---------------start------------->8---
We have \begin{equation*}
--8<---------------cut here---------------end--------------->8---

The motivation for the slightly convoluted code is that, when point is
at beginning of line, (save-excursion (join-line)) places point just
before " \begin" (rather than just before "\begin", as one might have
expected).  On the other hand, it behaves in the expected way if point
occurs later in the line (e.g., after "}").  Rather than trying to
understand exactly why join-line behaves this way (which seems like a
potentially non-robust feature that could change in the future), it
seemed simpler just to do the little dance that you see in the code.
I've added a comment to the code summarizing the above.

> We have to keep
> (setq pos nil)
> after `set-marker', which doesn't change the value of `pos' itself.

Thanks, good catch.

> As far as I can see, the proposed feature doesn't support docTeX mode. I
> don't think that is a practical problem at all, but addition of FIXME
> comment and breif mention about it in the documentation would be nice.

I'll trust you on this one -- I'm regrettably ignorant of TeX outside a
limited practical subset of LaTeX.  I've added some FIXME comments,
hopefully as intended.

There remains the question of where in the manual to document
LaTeX-modify-math and whether to illustrate it via examples like in my
earlier email.

Thanks, best,

Paul

[0001-Add-LaTeX-modify-math-and-LaTeX-make-inline.patch (text/x-patch, attachment)]

Message #44 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Ikumi Keita <ikumi <at> ikumi.que.jp>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Thu, 05 Jun 2025 23:51:42 +0900

Hi Paul,

>>>>> "Paul D. Nelson" <ultrono <at> gmail.com> writes:
> Suppose the buffer contains:
> We have
> \begin{equation*}
>   x + y = z.
> \end{equation*}

> With point on line 2, join-line yields a buffer with first line:
> We have \begin{equation*}
> The motivation for the slightly convoluted code is that, when point is
> at beginning of line, (save-excursion (join-line)) places point just
> before " \begin" (rather than just before "\begin", as one might have
> expected).

Thanks for explanation. Hmm, it's indeed annoying. :-(

> I'll trust you on this one -- I'm regrettably ignorant of TeX outside a
> limited practical subset of LaTeX.

To have a minimum acquaintance with docTeX document, visit
latex/preview.dtx in AUCTeX repository. It's basically full of
"commented" text with leading "%" sign at the beginning of line.

> I've added some FIXME comments, hopefully as intended.

Thank you, those are enough.

+(defun LaTeX-modify-math (new-type)
+  "Modify the current math construct to NEW-TYPE.
+
+Interactively, prompt for NEW-TYPE from a list of inline math
+delimiters (\"$\", \"\\(\"), display math delimiters (\"$$\",
+\"\\=\\[\") and valid LaTeX environments (\"equation\", ...).
+
+Non-interactively, NEW-TYPE must be either
+- a string specifying the target delimiter or environment name, or
+- a cons cell ((OPEN . CLOSE) . INLINE), where OPEN and CLOSE are
+  delimiters and INLINE is non-nil if the math construct is to be
+  understood as inline.
+
+The function converts the math construct at point (inline, display, or
+environment) to the specified NEW-TYPE, preserving the content.  If
+point is not in a math construct, signal an error.  Clears any active
+previews at point before modification.
+
+Does not support modifying macro-based constructs such as \\ensuremath."
+  ;; FIXME: this function may not work correctly in docTeX
+  (interactive
+   (let* ((type (progn (texmathp) (car texmathp-why)))
+          (tbl (append '("$" "\\(" "$$" "\\[")
+                       (LaTeX--math-environment-list))))

It seems `let' is enough. (I don't know the C implementation of `let'
and `let*' of elisp; maybe is there any guideline which recommends
`let*' over `let', due to the implementation detail, when both can do
the job equally?)

+     (barf-if-buffer-read-only)
+     (unless type (user-error "Not inside math"))
+     (LaTeX--closing type) ;; Check for errors.
+     (list (completing-read
+            (format "Convert %s → " type) tbl nil t nil nil
+            type))))
+  (let ((new-open (if (stringp new-type)
+                      new-type
+                    (caar new-type)))
+        (new-close (if (stringp new-type)
+                       (LaTeX--closing new-type)
+                     (cdar new-type)))
+        (new-inline (if (stringp new-type)
+                        (member new-type '("$" "\\("))
+                      (cdr new-type))))
+    (when (fboundp 'preview-clearout-at-point)
+      (preview-clearout-at-point))
+    (unless (called-interactively-p 'any)
+      (unless (texmathp) (error "Not inside math")))
+    (let ((type (car texmathp-why))
+          (math-start (cdr texmathp-why))
+          (pos (point-marker)))
+      (set-marker-insertion-type pos
+                                 (not
+                                  (and
+                                   (< (point) (point-max))
+                                   (save-excursion
+                                     (forward-char)
+                                     (not (texmathp))))))
+      (goto-char math-start)
+      (let* ((open (if (member type '("\\(" "$" "\\[" "$$"))
+                       type
+                     (concat TeX-esc "begin" TeX-grop type TeX-grcl)))
+             (close (LaTeX--closing type)))

Same comment with respect to `let' and `let*'.

+        (if (or (not (stringp new-type))
+                (member new-open '("$" "\\(" "\\[" "$$")))
+            ;; Conversion to inline or non-environment display.
+            (let* ((inline (member type '("$" "\\("))))

Same comment.

> There remains the question of where in the manual to document
> LaTeX-modify-math and whether to illustrate it via examples like in my
> earlier email.

AUCTeX manual already has "Mathematics" node, so I think you should add
explanation there.
Examples are welcomed in the manual. Users who don't know elisp well
will know how to use the prepaired function.

> (defun my-LaTeX-make-brackets ()
>   "Convert math construct at point to \"\\=\\[..\\=\\]\"."
                                                  ^^^
I'd suggest to remove quotation for \]. In contrast to \[, \] will be
displayed literally without \=, though extra \= is harmless.

Regards,
Ikumi Keita
#StandWithUkraine #StopWarInUkraine
#Gaza #StopMassiveKilling #CeasefireNOW

Message #47 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Ikumi Keita <ikumi <at> ikumi.que.jp>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Sun, 08 Jun 2025 16:05:19 +0200

[Message part 1 (text/plain, inline)]

Hi Ikumi,

I fixed the let/let* issues you noted.

> AUCTeX manual already has "Mathematics" node, so I think you should add
> explanation there.
> Examples are welcomed in the manual. Users who don't know elisp well
> will know how to use the prepaired function.

I've updated the attached patch with docs (so I think it's now in good
shape, but I always welcome feedback on my texinfo).

>> (defun my-LaTeX-make-brackets ()
>>   "Convert math construct at point to \"\\=\\[..\\=\\]\"."
>                                                   ^^^
> I'd suggest to remove quotation for \]. In contrast to \[, \] will be
> displayed literally without \=, though extra \= is harmless.

Done.  Any further feedback welcome!

Paul

[0001-Add-LaTeX-modify-math-and-LaTeX-make-inline.patch (text/x-patch, attachment)]

Message #50 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Ikumi Keita <ikumi <at> ikumi.que.jp>
To: "Paul D. Nelson" <ultrono <at> gmail.com>
Cc: arash <at> gnu.org, 78586 <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Tue, 10 Jun 2025 03:23:34 +0900

Hi Paul,

>>>>> "Paul D. Nelson" <ultrono <at> gmail.com> writes:
> I've updated the attached patch with docs (so I think it's now in good
> shape, but I always welcome feedback on my texinfo).

Thank you. Now I agree with your perspective. Please commit it into the
git repo and close the bug.

Regards,
Ikumi Keita
#StandWithUkraine #StopWarInUkraine
#Gaza #StopMassiveKilling #CeasefireNOW

Message #55 received at 78586-done <at> debbugs.gnu.org (full text, mbox):

From: "Paul D. Nelson" <ultrono <at> gmail.com>
To: Ikumi Keita <ikumi <at> ikumi.que.jp>
Cc: arash <at> gnu.org, 78586-done <at> debbugs.gnu.org
Subject: Re: bug#78586: TeX-make-inline
Date: Mon, 09 Jun 2025 21:01:59 +0200

Thanks Ikumi, I pushed the change and hope this message closes it!

Paul

Message #58 received at 78586 <at> debbugs.gnu.org (full text, mbox):

From: Arash Esbati <arash <at> gnu.org>
To: 78586 <at> debbugs.gnu.org
Cc: ultrono <at> gmail.com
Subject: Re: bug#78586: TeX-make-inline
Date: Wed, 11 Jun 2025 08:48:27 +0200

"Paul D. Nelson" <ultrono <at> gmail.com> writes:

> Thanks Ikumi, I pushed the change and hope this message closes it!

Thanks Paul.  I also added an entry about the new commands to NEWS.org.

Best, Arash

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.