How to use <Leader> in a normal command?

I made up a solution to extract the leader, handle the special <space> case and execute the normal command.

The space is a special case, because the normal command does not accept expressions starting with a space:

:h normal {commands} cannot start with a space. Put a count of 1 (one) before it, "1 " is one space. 

Here is the function and command:

function! ExecuteLeader(suffix) let l:leader = get(g:,"mapleader","\\") if l:leader == ' ' let l:leader = '1' . l:leader endif execute "normal ".l:leader.a:suffix endfunction command! -nargs=1 NormLead call ExecuteLeader(<f-args>) 

You can use it this way:

:NormLead a -> will execute `normal <leader>a` 

(Thanks @statox for the update): If you want a one-liner command, without function, you can use the following:

command! -nargs=1 NormLead let leader=get(g:,"mapleader","\\") | exec "normal " . (leader==' '?"1":leader).<f-args> 

This is just for the leader key, but if you want to extend to any kind of key I think you need to use execute anyway.

In the normal help:

An alternative is to use :execute, which uses a expression as argument. This allows the use of printable characters to represent special characters. Example: :exe "normal \<c-w>\<c-w>" {not in Vi, of course} 

The fundamental problem, here, is that "leader mappings" are not special mappings in any way. The <leader> in nnoremap <Leader>a Yp is expanded to whatever :help mapleader is set to at the time of definition:

:let mapleader = "," :nnoremap <Leader>a Yp :filter Yp nmap n ,a * Yp 

If the value of mapleader changes after a "leader mapping" has been defined, then the mapping is not changed:

:let mapleader = "\<Space>" :filter Yp nmap n ,a * Yp 

It is quite easy to end up with a silly mess, even:

:nnoremap <Leader>a Yp :filter Yp nmap n <Space>a * Yp n ,a * Yp 

Said another way, <Leader> is not consumed at runtime but at "source-time". Vim discards that <Leader> string as soon as it defines the mapping, so there is no way to tell if a mapping was defined with <Leader>, and no way to recall it with <Leader> either. This:

:let mapleader = "," :nnoremap <Leader>a Yp 

and this:

:nnoremap ,a Yp 

have exactly the same outcome: a mapping on ,a.

What you think of as a "leader mapping" when you edit your vimrc loses any trace of "leader-osity" the moment the line is executed. So, it is actually quite easy to use the current value of mapleader in a :normal command:

:normal <C-r>=get(g:, 'mapleader', '\')<CR>a 

or, if you feel confident/lazy:

:normal <C-r>=mapleader<CR>a 

But what ends up being executed is <CurrentLeader>a, which may or may not be the same as <LeaderAtDefinitionTime>a.

The value of mapleader at the time the mapping was defined is definitely lost. All you have is a ,a mapping so the snippet above can only really be used if the the current value of mapleader is the same as when the mapping was defined, , in this case.

If it is not, then you are at a dead end.

call feedkeys(l:leader . a:suffix, 'm') works in Vim 9.1 (Included patches: 1-818).

Whole code for Vim and NeoVim:

command! -nargs=1 NormLead call Executeleader(<f-args>) function! Executeleader(suffix) " Get mapleader, default to backslash if not set let l:leader = get(g:,"mapleader","\\") " Special handling for space leader in Neovim if l:leader == ' ' && has('nvim') let l:leader = '1 ' endif " For Vim with space leader, l:leader remains ' ' (no conversion needed) " Debugging - uncomment if needed (may fail in Vim, works in Neovim) " echo "l:leader --> " . "'" . l:leader . "'" " echo "a:suffix --> " . "'" . a:suffix . "'" " sleep 1 " Execute the leader key sequence " The 'm' flag ensures the key sequence is executed immediately call feedkeys(l:leader . a:suffix, 'm') " Example: call feedkeys(' CFa', 'm') for space leader + CFa " Why this approach works: " - execute "normal \ CFa" fails in Vim (space interpreted as range separator) " - feedkeys() bypasses the range interpretation issue endfunction