Is there a simple way to remove a single keyword from a syntax group (or otherwise override it in a match)?

Question

I occasionally like to tinker with syntax files (especially conceals; I use λ for anonymous functions (lambda:, fn) in several languages).

However, one complaint with conceal is that I can only use a single character. When concealing, e.g., fn, having one character breaks some vertical alignment. One solution is to use λ. instead, keeping the two characters and aligning with the lambda-calculus origins.

In at least two syntax files I use, fn is part of a syn-keyword definition. In order to use the λ. above, I need to do something like this:

syn match group /fn\@=/ conceal cchar=λ
syn match group /fn\@<=/ conceal cchar=.

However, syn-matchs have lower priority, so these don't apply. The original

syn keyword group fn conceal cchar=λ

works just fine, because it is a keyword defined later.

---

TL;DR

I would like to either

• remove fn from a syntax keyword group, or
• override a keyword from a match

One possible solution is

syn clear group
" re-add everything else
" syn keyword group ...

But this fails when group has more than just keywords and is very complex. It's also not scalable at all.

---

I'm open to some kind of meta-programming/parsing the output of syn list, but it needs to be quasi-readable/understandable.

---

Here's a clojure example:

; should be concealed?
fn [x]
; definitely should be
(fn [x] x)
; definitely should be
( fn [x])
; shouldn't be, though my current keyword solution would
(let [fn 1] fn)
; same
(let [ fn 1] fn)
; definitely shouldn't be
(let [afn 1] afn)

And here's one from sml

(* should conceal *)
val id = fn x => x
(* also should conceal *)
val _ = (fn x => x) id
(*
  technically this isn't valid SML, but it should conceal
  and it demonstrates a beginning-of-line issue
*)
fn x => x

Answer 1

Here's a solution using a different technique to the two you suggested:

syntax match lambda /\_.\<fn\>/ containedin=ALL
syntax match lam /f/ containedin=lambda contained conceal cchar=λ
syntax match bda /n/ containedin=lambda contained conceal cchar=.

Syntax items which start in an earlier position in the buffer take priority over other items, so we set up a group that will start just before the fn, and then add our conceal groups inside that.

Unfortunately you don't mention what language or syntax files you're using so it's not fully tested, but it works for me in the following block of PHP:

$modifier = 5;
array_map(fn($x) => $x * $modifier, $numbers);

Update

The above was written before the specific languages and examples were added to the question, and doesn't work well when used within Vim's standard Clojure highlighting. Here's a solution that works (exclusively) inside a Clojure s-expression:

syntax region lambda matchgroup=clojureParen start="(\zefn" end=")" containedin=clojureSexp
syntax match lam /f/ contained containedin=lambda conceal cchar=λ nextgroup=bda
syntax match bda /n/ contained conceal cchar=. nextgroup=aaa
syntax match aaa /[^)]*/ contains=@clojureTop contained

Unfortunately, it's (necessarily) a lot more tightly integrated with the existing syntax items, because of the way the various nested groups connect.

It works by creating a lambda group that can be found within and which spans an entire clojureSexp, when this clojureSexp begins with an instance of fn. Inside this group are then the lam and bda groups which match the f and n respectively, and these are followed by an aaa group which contains the rest of the normal Clojure syntax items that can be found within an s-expression.

And here's a version that highlights all the other cases:

syntax match lambda /\_[^(]\<fn\>/ containedin=ALL
syntax match lambda /\_[^(]\{2}\<fn\>/ containedin=ALL transparent contains=NONE
syntax match lam /f/ containedin=lambda contained conceal cchar=λ
syntax match bda /n/ containedin=lambda contained conceal cchar=.

Combining the two is left as an exercise for the reader. The simplest method is just to use two entirely separate sets of syntax groups with different names, but there's probably a more succinct solution:

Answer 2

Here's a completely different, arguably even more hacky, but much simpler solution:

syntax keyword lam fn conceal cchar=λ containedin=ALL nextgroup=bda
execute "syntax match bda ' ' conceal cchar=\uff0e"

It relies on:

1. There always being a space after the fn keyword: we're matching this space as well as the fn.
2. Unicode support: we're replacing the space with a full width dot.