How to support `<` and `>` as balanced parens without impacting ability to use them as comparison operators?

Question

Languages like Erlang and Elixir use << >> for binaries and bit-string syntax, but they also use the classical < and > for comparison operators as well as -> and <- in list comprehensions.

Emacs syntax-table has the ability to identify pairs of characters. The ( ), [ ] and { } character pairs are identified in the syntax table as character pairs.

This allows the following very handy behaviours:

• forward-sexp and backward-sexp commands to navigate to the matching pair,
• er/expand-region to quickly mark all text with the pair.

Adding the < > pair in the syntax table causes problems with the other uses of the < and > characters because Emacs will see unbalanced pairs in statements such as if (a < 3).

Question:

Is there a way to solve this problem and get the ability to use commands such as forward-sexp and er/expand-region to see the << >> as balanced pairs when they are working on them, without adding balanced pair-syntax to < and >?

For instance, to overcome the problem, would it be a good idea to dynamically change the syntax of < and > by modifying the syntax table just around the execution of these commands when they are applied on those characters (using advice or re-writing a function that calls them)?

Answer 1

Yes. The syntax of a character in a buffer defaults to the value indicated by the buffer's syntax table, but this can be overridden by setting the syntax-table text property on a character in a buffer, provided that parse-sexp-lookup-properties is true. And you can set syntax-propertize-function to a function that applies this property as needed to a stretch of text. Modes written for older versions of Emacs that didn't have syntax-propertize-function could use font locking or custom post-change hooks for that.

For simple cases, the syntax-propertize-rules macro can generate a suitable syntax-propertize-function. It's similar to font lock keywords, but sets character syntaxes rather than faces.

The example below (untested) makes the outer characters in <<…>> matching balanced open-close characters.

(defconst foo-mode-syntax-propertize-function
  (syntax-propertize-rules
   ("\\(<\\)<" (1 "(>"))
   (">\\(>\\)" (2 ")<"))))
(defun foo-mode ()
  …
  (make-local-variable 'parse-sexp-lookup-properties)
  (setq parse-sexp-lookup-properties t)
  (make-local-variable 'syntax-propertize-function)
  (setq syntax-propertize-function foo-mode-syntax-propertize-function)
)

For a working, real-world example of making <<…>> balanced, see Erlang mode. It only sets the syntax when inserting < or > explicitly, which is very limited. I guess this code was written a long time ago before syntax-propertize-function made it more convenient.

There are several examples of using syntax-propertize-function as intended in modes distributed with Emacs. For example, bat mode uses syntax-propertize-rules to make things like the word rem be a multi-character content starter. Fortran mode has a somewhat more complicated rule to recognize the C comment marker in the proper column. For a much more example, look at the various things Perl mode does to accommodate some of Perl's syntactic complexity.

If you want to see a really complex example, explore how CC mode makes <…> balanced where warranted in C++.