Forem: Linwei

Can't believe I've created 20 vim plugins since 2016

Linwei — Tue, 22 Oct 2024 10:00:29 +0000

Maybe you'll be interested in some of them:

asyncrun - 🚀 Run Async Shell Commands in Vim 8.0 and NVim and Output to the Quickfix Window !!
asynctasks - 🚀 Modern Task System for Project Building, Testing and Deploying !!
gutentags_plus - The right way to use gtags with gutentags
Leaderf-snippets - Intuitive way to use snippets
vim-auto-popmenu - 😎 Display the Completion Menu Automantically !!
vim-color-export - 🌈 A tool to backport NeoVim colorschemes to Vim !!
vim-color-patch - 🌈 Load colorscheme patch script automatically !!
vim-cppman - Read Cppman/Man pages right inside your vim.
vim-dict - Automatically add dictionary files to current buf according to filetype.
vim-gpt-commit - 🚀 Generate git commit message using ChatGPT/Ollama !!
vim-gutentags - manages your ctags/gtag files automatically.
vim-init - vimrc tutorials and startup framework.
vim-keysound - 🍷 Play typewriter sound in Vim when you are typing a letter
vim-navigator - 🚀 Navigate Your Commands Easily !!
vim-preview - The missing preview window for vim
vim-quickmenu - A nice customizable popup menu for vim
vim-quickui - The missing UI extensions for Vim 9 (and NeoVim) !! 😎
vim-rt-format - 😎 Prettify Current Line on Enter !!
vim-terminal-help - Small changes make vim/nvim's internal terminal great again.
vim-text-process - Text Filter Manager for Vim !!

What's New Since Vim 9.0?

Linwei — Wed, 24 Jul 2024 09:54:37 +0000

Since the release of version 9.0.0, Vim has introduced many exciting new features, such as Vim9 classes/interfaces and virtual text, which have significantly enhanced the overall user experience.

Here is a comprehensive list of new features introduced since Vim 9.0:

Vim 9.1

9.1.0572: new tabclose option to specify tab page closing behaviour.
9.1.0548: id() function
9.1.0509: bindtextdomain()
9.1.0507: CursorMovedC event to monitor cursor movement in command mode.
9.1.0500: popup_setbuf() to switch buffer in a popup.
9.1.0476: new highlighting groups: PmenuMatch and PmenuMatchSel to see matched text in popup menu.
9.1.0469: make completeopt to have buffer-local value
9.1.0465: copyfile() to copy file.
9.1.0439: new :filter :history to filter the history.
9.1.0394: getregionpos()
9.1.0393: support $XDG_CONFIG_HOME
9.1.0147: new winfixbuf option to prevent buffer switching in one window.
9.1.0120: getregion()
9.1.0071: diff() to compare lists or strings.
9.1.0059: WinNewPre event before creating a window.
9.1.0058: new :map-cmd-key, try :imap <D-b> bar
9.1.0027: foreach() function
9.1.0010: keymap completion
9.1.0009: new matchstrlist() and matchbufline() functions.

Vim 9.0

9.0.2183: new "maxfuncdepth" option
9.0.1950: new() function
9.0.1786: instanceof() function
9.0.1777: new v:python3_version
9.0.1776: python3-stable-api
9.0.1704: can use positional arguments for printf() .
9.0.1485: strutf16len() and utf16idx()
9.0.1276: new ":map-meta-keys", try imap <T-b> terrible
9.0.1212: new getcellwidths() function.
9.0.1122: new :autocmd-block
9.0.1031: vim9 class/interface.
9.0.1007: swapfilelist()
9.0.0819: new endofline and endoffile option
9.0.0881: new getmouseshape() function
9.0.0916: new getbufoneline() function.
9.0.0683: popup_findecho()
9.0.0647: new splitkeep option
9.0.0640: smoothscroll
9.0.0496: drop Windows-XP support. (PR #11089)
9.0.0449: keytrans()
9.0.0370: new ":defer" command to call function when current function is done.
9.0.0321: new ":echow" command to display message in a popup window.
9.0.0285: setcmdline()
9.0.0244: getscriptinfo()
9.0.0196: indexof() function to search item in list/string
9.0.0067: virtual-text
9.0.0009: matchbufline() and matchstrlist()
9.0.0007: terminal support for double, dotted and dashed underlines

Why does the indexing of array start with ZERO in C?

Linwei — Tue, 08 Aug 2023 07:55:11 +0000

Most programming languages today, including C, use a zero-based index for arrays due to some compelling reasons.

Better addressing

If a C language array starts from 0, the address of array[i] would be exactly:

(array + i)

which is very consistent. But if it starts from 1, the address of array[i] would be:

(array + i - 1)

One more computation would affect the performance, and it would be even worse if extended to a two-dimensional array.

For ZERO-based indexing, the address of array[i][j] is

(array + i * N + j)

which is very neat. But for 1-based indexing, the address of array[i][j] will become:

(array + (i - 1) * N + (j - 1))

It would be more cumbersome. Additionally, if we start with 1, the same address cannot be addressed uniformly using "pointer + offset" and "array + index", and conversion is often required. So, why bother?

Computer hardware is designed to use 0 as the starting index

Physical memory addressing and port addressing both start from 0. For example, the address range of a 32-bit computer's memory is:

[0, 2 ^ 32 - 1]

which can be represented by a 32-bit integer. However, if the memory is addressed starting from 1, then the address range of a 32-bit computer becomes:

[1, 2 ^ 32]

In that case, the highest address 2 ^ 32 would require a 33-bit integer, which would be a waste of resources.

Other port addresses and DMA channels also follow this starting from 0 principle. If we use 3 bits to represent DMA channels, it is better to express 8 channels (0-7), while starting from 1, the same 3 bits can only express 7 channels (1-7), which is also a waste of resources.

Therefore, a language that is close to the system naturally chooses to follow the hardware settings. In addition to the simpler addressing calculation mentioned in the first point, it can also maintain consistency with the computer system and unify the user experience of pointer addressing and array addressing.

Dijkstra explained that the reason programming languages do this is simply to follow hardware design decisions:

The decision taken by the language specification & compiler-designers is based on the decision made by computer system-designers to start count at 0.

Therefore, C language arrays start at zero for the following reasons: 1) Better performance; 2) Unified array and pointer addressing; 3) Following hardware addressing conventions.

In addition to these practical reasons, there are also some theoretical reasons.

Theoretical reasons

Apart from array indexing, Dijkstra advocated that all counting should start from 0, and he wrote an article to explain this viewpoint:

https://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF

He explicitly criticized early languages like Fortran and Pascal that started from 1 for not considering enough:

He gave an impeccable reason, probably arguing that there are several ways to express the integer sequence 2, 3, 4, ..., 12.

a）2 <= i < 13
b）1 < i <= 12
c）2 <= i <= 12
d）1 < i < 13

Then he explained:

For the left side, the expression "a <= x" is better than "a < x" because if "a < x" is used to express a sequence, you always need to provide a number that is smaller than the first element, which is not only annoying but also often impossible (there exists a smallest rational number, but there is no largest rational number). Therefore, "a <= x" is a better expression.

For the right side, the expression "x < b" is better than "x <= b" because when a = b, "a <= x < b" can represent an empty set while "a <= x <= b" cannot represent an empty set.

Both scheme (a) and scheme (b) can easily show the length of the sequence.

Scheme (a) and scheme (d) are easier to express adjacent sequences.

Thus, it was proved that the left-closed and right-open scheme (a) "a <= x < b" is more suitable for expressing a sequence.

After Dijkstra argued that "a <= x < b" is a better choice, he concluded that an array of length N should start from 0, because the expression "0 <= x < N" is clearer than "1 <= x < N+1".

Benchmark asyncio vs gevent vs native epoll

Linwei — Tue, 13 Dec 2022 12:49:49 +0000

Everyone knows the asyncio module in python schedules all coroutines in a single thread. That means it helps you code easier, and you can't gain any performance from it.

But what is the performance of python's asyncio module? How fast can it run compared to traditional gevent and native epoll ?

Requirements

pip3 install hiredis gevent

An optional package uvloop can also be install if working on Linux:

pip3 install uvloop

Source

The following code uses both asyncio and gevent to simulate a redis server on port 5000, 5001, and 5002.

They can be tested with redis-benchmark.

content of echo_bench_gevent.py:

import sys
import gevent
import gevent.monkey
import hiredis

from gevent.server import StreamServer
gevent.monkey.patch_all()

d = {}

def process(req):
    # only support get/set
    cmd = req[0].lower()
    if cmd == b'set':
        d[req[1]] = req[2]
        return b"+OK\r\n"
    elif cmd == b'get':
        v = d.get(req[1])
        if v is None:
            return b'$-1\r\n'
        else:
            return b'$1\r\n1\r\n'
    else:
        print(cmd)
        raise NotImplementedError()
    return b''

def handle(sock, addr):
    reader = hiredis.Reader()
    while True:
        buf = sock.recv(4096)
        if not buf:
            return
        reader.feed(buf)
        while True:
            req = reader.gets()
            if not req:
                break
            sock.sendall(process(req))
    return 0

print('serving on 0.0.0.0:5000')
server = StreamServer(('0.0.0.0', 5000), handle)
server.serve_forever()

content of echo_bench_asyncio.py:

import asyncio
import hiredis

d = {}

def process(req):
    cmd = req[0].lower()
    if cmd == b'set':
        d[req[1]] = req[2]
        return b"+OK\r\n"
    elif cmd == b'get':
        v = d.get(req[1])
        if v is None:
            return b'$-1\r\n'
        else:
            return b'$1\r\n1\r\n'
    elif cmd == b'config':
        return b'-ERROR\r\n'
    else:
        return b'-ERROR\r\n'
    return b''

async def echo_server(reader, writer):
    hireader = hiredis.Reader()
    while True:
        s = await reader.read(4096)
        if not s:
            break
        hireader.feed(s)
        while True:
            req = hireader.gets()
            if not req:
                break
            res = process(req)
            writer.write(res)
            await writer.drain()
    return 0

async def main():
    server = await asyncio.start_server(echo_server, '0.0.0.0', 5001)
    print('serving on {}'.format(server.sockets[0].getsockname()))
    await server.serve_forever()
    return 0

asyncio.run(main())

content of echo_bench_asyncio_uvloop.py:

import asyncio
import hiredis

d = {}

def process(req):
    cmd = req[0].lower()
    if cmd == b'set':
        d[req[1]] = req[2]
        return b"+OK\r\n"
    elif cmd == b'get':
        v = d.get(req[1])
        if v is None:
            return b'$-1\r\n'
        else:
            return b'$1\r\n1\r\n'
    elif cmd == b'config':
        return b'-ERROR\r\n'
    else:
        return b'-ERROR\r\n'
    return b''

async def echo_server(reader, writer):
    hireader = hiredis.Reader()
    while True:
        s = await reader.read(4096)
        if not s:
            break
        hireader.feed(s)
        while True:
            req = hireader.gets()
            if not req:
                break
            res = process(req)
            writer.write(res)
            await writer.drain()
    return 0

async def main():
    server = await asyncio.start_server(echo_server, '0.0.0.0', 5002)
    print('serving on {}'.format(server.sockets[0].getsockname()))
    await server.serve_forever()
    return 0

try:
    import uvloop
    uvloop.install()
    print('uvloop is enabled')
except ImportError:
    print('uvloop is not available')

asyncio.run(main())

Start servers

python3 echo_bench_gevent.py          # will listen on port 5000
python3 echo_bench_asyncio.py         # will listen on port 5001
python3 echo_bench_asyncio_uvloop.py  # will listen on port 5002

Test

redis-benchmark -p 5000 -t get -n 100000 -r 100000000
redis-benchmark -p 5001 -t get -n 100000 -r 100000000
redis-benchmark -p 5002 -t get -n 100000 -r 100000000

Result

Mode	Python 3.9	Python 3.11
gevent	34281.80 requests / second	32258.07 requests / second
asyncio	40144.52 requests / second	51652.89 requests / second
asyncio + uvloop	64102.57 requests / second	66577.90 requests / second

Native epoll

Redis is implemented with epoll in C, and we can test redis directly:

redis-benchmark -p 6379 -t get -n 100000 -r 100000000

Output:

75244.55 requests per second

Conclusion

asyncio is 50% faster than gevent in Python 3.11
asyncio can run twice as fast as gevent with uvloop.
asyncio can go up to 68% of a native epoll program.
asyncio can go up to 88% of a native epoll program with uvloop.

asyncrun.vim: run commands in iterm2, tmux, or gnome/kde terminal

Linwei — Tue, 04 Jan 2022 19:08:56 +0000

asyncrun.vim was known as a shell command runner in the quickfix window. However, it first got released six years ago (2016), when the +job feature just became stable in vim 7.4.1829. During these years, numerous issues have been addressed, and valuable feedbacks got collected.

At the beginning of 2022, I'd like to share some recent changes which may be helpful to improve your productivity.

New runners

Both Vim and NeoVim got +terminal features for years, but some people still used to run new jobs in system terminals, like gnome-terminal, xfce-terminal, iterm2, or konsole.

With the power of user-defined runners, you can run commands anywhere you want instead of in the quickfix window. Some pre-included runners can be used to interact with those external system terminals:

Runner	Description	Requirement
`gnome`	in a new gnome terminal	GNOME
`gnome_tab`	in a new gnome terminal tab	GNOME
`xterm`	in a xterm window	xterm
`tmux`	in another tmux split	Vimux
`xfce`	in a new xfce terminal	xfce4-terminal
`konsole`	in a new konsole terminal	KDE
`macos`	in a macOS system terminal	macOS
`iterm`	in a new iterm2 tab	macOS + iTerm2
`external`	in a new cmd.exe window	Windows

When using asyncrun with -mode=term, you can provide an option -pos={runner} to specify runner name:

:AsyncRun -mode=term -pos=gnome      ls -la
:AsyncRun -mode=term -pos=floaterm   ls -la
:AsyncRun -mode=term -pos=tmux       ls -la

When using gnome, konsole, external, or xfce runner in GVim, you can get exactly the same experience like starting a command-line program from IDEs:

If you are using terminal vim, a new gnome-terminal tab, or iterm2 tab may be a good start:

or perhaps in a tmux split:

Besides the system terminal, there are also runners for some most famous internal terminal plugins:

Runner	Description	Requirement
`floaterm`	in a new floaterm window	floaterm
`floaterm_reuse`	in a reusable floaterm window	floaterm
`quickui`	in a quickui window	vim-quickui
`toggleterm`	in a toggleterm window	toggleterm.nvim
`termhelp`	in terminal help	vim-terminal-help

Screenshot for the floaterm runner:

Terminal-help:

All runners are customizable, you can modify or define your own runners, see the customize runner page.

Internal terminal

Another exciting feature is interacting with (neo)vim's internal terminal:

" run command in the internal-terminal in a new tab 
:AsyncRun -mode=term -pos=tab    ls -la
:AsyncRun -mode=term -pos=TAB    ls -la

" open on the left/right/top/bottom side
:AsyncRun -mode=term -pos=left   ls -la
:AsyncRun -mode=term -pos=right  ls -la
:AsyncRun -mode=term -pos=top    ls -la
:AsyncRun -mode=term -pos=bottom ls -la

You may ask that you can directly use the builtin :term xxx command to start the internal terminal, what is the difference to use :AsyncRun for this ?

The main reasons are convenience and flexibility:

Macros like $(VIM_FILENAME) or $(VIM_ROOT) can be expanded in the command:
```
:AsyncRun -mode=term -pos=TAB  ls -la $(VIM_FILEDIR)
```

Working directory can be customized by -cwd= option:

:AsyncRun -mode=term -pos=TAB -cwd=~/github  ls -la

Easier to specify the opening position and size:

:AsyncRun -mode=term -pos=bottom -rows=8  ls -la
:AsyncRun -mode=term -pos=right -cols=40  ls -la

No distraction and prevent focus changing by providing -focus=0 option:
```
:AsyncRun -mode=term -pos=tab -focus=0  ls -la
```
Can close the terminal window automatically when job is finished if -close option presents.
```
:AsyncRun -mode=term -pos=tab -focus=0 -close ls -la
```

Run a vim command when job finished by -post=xxx

:AsyncRun -mode=term -post=echo\ 'notify'   ls -la

And there are some more benefits:

Environment variables like $VIM_FILENAME can be initialized correctly.
Prevent listing terminal buffer in the buffer-list by -listed=0.
Set bufhidden to hide for terminal buffer by -hidden=1.
Reuse the previous terminal window by -reuse.
Notify can be setup by -post=xxx option.
Corresponding experience in both vim and neovim.

The most important thing is that vim/neovim's :term command can't escape complex strings correctly in Windows or some rare shells when arguments contain white spaces or quotes and bars. AsyncRun can pass arguments precisely as what they are.

My favorite terminal position is -pos=TAB, different with lower case -pos=tab, it will open a new terminal tab on the left side of my current tabpage:

I use it a lot to execute the current file because when it is finished, the tab will close, and it will return to the previous tabpage where I was working.

Excluding macro variables substitution, some of the actions above can be achieved by original :term with one or more other commands. Still, asyncrun provides a unified interface for these trivial things in one command and eliminates the difference between vim and neovim.

Summary

asyncrun.vim provides you with all the possible ways to run commands in vim with no compromise. Feel free to choose the one you like, and don't forget to check the command specification for more.

Bonus: If you find mapping asyncrun commands for different projects or file-types challenging, you may be benefit from a sibling plugin asynctasks.vim, it uses asyncrun as the backend and introduces vscode like task system in vim.

Vim 2022: 🍷 Play typewriter sound in Vim when you are typing a letter

Linwei — Thu, 30 Dec 2021 17:35:18 +0000

It's cool to play typewriter sound in Vim when you are typing a letter. 😎

So I made a little [script] for this:

Plug 'skywind3000/vim-keysound'
let g:keysound_enable = 1
let g:keysound_theme = 'default'

" volume range is from 0 to 1000
let g:keysound_volume = 500

Then

apt-get install python3-sdl2

Make sure that your vim has +python3 feature enabled.

And you go.

See this video by Keefle (there is no audio delay in reality).

https://streamable.com/yah0h

The world of desktops, laptops will never understand

Linwei — Sat, 25 Dec 2021 15:14:25 +0000

Study Japanese in the Command Line !

Linwei — Thu, 23 Dec 2021 18:23:29 +0000

Do you want to study Japanese? How many times did you fail in remembering hiragana/katakana? Is there a easy way to master them ?

Yes, you can learn and practice kanas now in the command line by playing KanaQuiz.

List kanas by

python3 kanaquiz.py -l

You can see hiraganas and katakanas right in your terminal:

Start a new quiz by

python3 kanaquiz.py -h

After pressing Enter, the quiz proceeds:

Read the kana character in the square brackets [ ] and input its romanized name after the question mark ? then press Enter ASAP to continue.

After finished, there will be a beautiful report:

Figure out which kana got the slowest response time (you are least likely to remember) and take time to practice.

The history reports can always be queried by:

python3 kanaquiz.py -q

Enjoy.

Vim 2022: Format your code in real-time !!

Linwei — Mon, 13 Dec 2021 16:17:16 +0000

There are plenty of code-formatting plugins, like auto-format and neoformat, for vim. But all of them require running a certain command or using :w to trigger formating.

Is it possible to see the immediate formatted code in the real-time ? If so, life could be much easier.

Therefore, I created a little plugin vim-rt-format, which can format the current line immediately in INSERT mode as soon as you press ENTER:

When you are focusing on editing, everything is done without paying extra attention. No need to stop your work to run an extra command like gq or :Neoformat.

Ready to try this out ? Firstly, +python3 feature must be enabled in your vim, check it by:

:echo has('python3')

It will return 1 if python is supported in your current vim version. If not, install a new vim with +python3 feature, for example in ubuntu/debian:

sudo apt-get install vim-nox

Secondly, a python module named autopep8 is required:

sudo pip install autopep8

Then add a few code in your .vimrc:

" Install the plugin with vim-plug:
Plug 'skywind3000/vim-rt-format'

" By default, it will be triggered by `ENTER` in insert mode.
" set this to 1 to use `CTRL+ENTER` instead, and keep the  
" default `ENTER` behavior unchanged.
let g:rtf_ctrl_enter = 0

" Enable formatting when leaving insert mode
let g:rtf_on_insert_leave = 1

And everything is ready, restart your vim, edit some files then you will have a nice day.

BTW: Currently, it supports python, lua and javascript.

Vim 2021: Add A Context Menu in You Vim

Linwei — Wed, 27 Jan 2021 07:58:12 +0000

A nice looking context menu is very useful when you have something to do with current word/line under cursor. And it can also remind you when you forget your keymaps:

Setup

With the help of the ui-extension plugin quickui, it can be simply defined like this:

Plug 'skywind3000/vim-quickui'

" define your context menu as a list of (text, command) pairs
let g:context_menu_k = [
            \ ["&Help Keyword\t\\ch", 'echo expand("<cword>")' ],
            \ ["&Signature\t\\cs", 'echo 101'],
            \ ['-'],
            \ ["Find in &File\t\\cx", 'exec "/" . expand("<cword>")' ],
            \ ["Find in &Project\t\\cp", 'exec "vimgrep " . expand("<cword>") . "*"' ],
            \ ["Find in &Defintion\t\\cd", 'YcmCompleter GotoDefinition' ],
            \ ["Search &References\t\\cr", 'YcmCompleter GoToReferences'],
            \ ['-'],
            \ ["&Documentation\t\\cm", 'exec "PyDoc " . expand("<cword>")'],
            \ ]

" map 'K' to display the context menu
nnoremap <silent>K :call quickui#tools#clever_context('k', g:context_menu_k, {})<cr>

Then when you press K, it will display around the cursor:

Context menu is a good place to organize your LSP commands.

Usage

navigate the items by j/k or arrow keys.
accept an item by Enter or Space or mouse left-click.
press ESC to quit.
Hot keys can be defined by a &.

The border and color are also customizable, check the quickui doc for more.

Plugin Dedicated Context

Context menu can also be used to enhance plugin experience, you can setup some buffer local keymap in the plugin buffer:

let g:context_menu_git = [
      \ ["&Stage (add)\ts", 'exec "normal s"' ],
      \ ["&Unstage (reset)\tu", 'exec "normal u"' ],
      \ ["&Toggle stage/unstage\t-", 'exec "normal -"' ],
      \ ["Unstage &Everything\tU", 'exec "normal U"' ],
      \ ["D&iscard change\tX", 'exec "normal X"' ],
      \ ["--"],
      \ ["Inline &Diff\t=", 'exec "normal ="' ],
      \ ["Diff S&plit\tdd", 'exec "normal dd"' ],
      \ ["Diff &Horizontal\tdh", 'exec "normal dh"' ],
      \ ["Diff &Vertical\tdv", 'exec "normal dv"' ],
      \ ["--"],
      \ ["&Open File\t<CR>", 'exec "normal \<cr>"' ],
      \ ["Open in New Split\to", 'exec "normal o"' ],
      \ ["Open in New Vsplit\tgO", 'exec "normal gO"' ],
      \ ["Open in New Tab\tO", 'exec "normal O"' ],
      \ ["Open in &Preview\tp", 'exec "normal p"' ],
      \ ["--"],
      \ ["&Commit\tcc", 'exec "normal cc"' ],
      \ ]

function! s:setup_fugitive()
    nnoremap <silent><buffer>K :call quickui#tools#clever_context('g', g:context_menu_git, {})<cr>
endfunc

augroup MenuEvents
    au!
    au FileType fugitive call s:setup_fugitive()
augroup END

When you are using fugitive, you can press K to display a fugitive menu:

No need to remember these seldom used fugitive keymaps, just K is totally enough.

You can also setup a context menu for defx.nvim:

This made defx more user-friendly.

Bash cd bookmark in 20 lines

Linwei — Mon, 20 Jan 2020 17:41:00 +0000

This is a small bash script, save it as m.sh:

# bash directory bookmark
function cd_mark() {
    MARKPATH="${MARKPATH:-$HOME/.local/share/marks}"
    [ -d "$MARKPATH" ] || mkdir -p -m 700 "$MARKPATH" 2> /dev/null
    case "$1" in
        +*)            # m +foo  - add new bookmark for $PWD
            ln -snf "$(pwd)" "$MARKPATH/${1:1}" 
            ;;
        -*)            # m -foo  - delete a bookmark named "foo"
            rm -i "$MARKPATH/${1:1}" 
            ;;
        /*)            # m /bar  - search bookmarks matching "bar"
            find "$MARKPATH" -type l -name "*${1:1}*" | \
                awk -F "/" '{print $NF}' | MARKPATH="$MARKPATH" xargs -I'{}'\
                sh -c 'echo "{} ->" $(readlink "$MARKPATH/{}")'
            ;;
        "")            # m       - list all bookmarks
            command ls -1 "$MARKPATH/" | MARKPATH="$MARKPATH" xargs -I'{}' \
                sh -c 'echo "{} ->" $(readlink "$MARKPATH/{}")'
            ;;
        *)             # m foo   - cd to the bookmark directory
            local dest="$(readlink "$MARKPATH/$1" 2> /dev/null)"
            [ -d "$dest" ] && cd "$dest" || echo "No such mark: $1"
            ;;
    esac
}

# by default, alias cd_mark to m
alias ${MARKCMD:-m}='cd_mark'

Then put a single line in your .bashrc or .zshrc:

source /path/to/m.sh

Or, you can simply copy & paste the content to your .bashrc or .zshrc.

Now you can have your m command to manipulate the directory bookmarks:

m +foo: add a new bookmark for your current working directory
m -foo: delete a bookmark
m foo: cd to the given bookmark directory
m /bar: search bookmarks matching "bar"
m: print a list of all bookmarks

cd to your most recently accessed directories and use m +foo to create a bookmark named foo, and use m foo to go back at anytime.

Let's polish it a little, for example, add a completion function for bash/zsh:

if [ -n "$BASH_VERSION" ]; then
    function _cdmark_complete() {
        local MARKPATH="${MARKPATH:-$HOME/.local/share/marks}"
        local curword="${COMP_WORDS[COMP_CWORD]}"
        if [[ "$curword" == "-"* ]]; then
            COMPREPLY=($(find "$MARKPATH" -type l -name "${curword:1}*" \
                2> /dev/null | awk -F "/" '{print "-"$NF}'))
        else
            COMPREPLY=($(find "$MARKPATH" -type l -name "${curword}*" \
                2> /dev/null | awk -F "/" '{print $NF}'))
        fi
    }
    complete -F _cdmark_complete ${MARKCMD:-m}
elif [ -n "$ZSH_VERSION" ]; then
    function _cdmark_complete() {
        local MARKPATH="${MARKPATH:-$HOME/.local/share/marks}"
        if [[ "${1}${2}" == "-"* ]]; then
            reply=($(command ls -1 "$MARKPATH" 2> /dev/null | \
                awk '{print "-"$0}'))
        else
            reply=($(command ls -1 "$MARKPATH" 2> /dev/null))
        fi
    }
    compctl -K _cdmark_complete cd_mark
fi

After that, when you press tab after m command, you can get suggestions from the completion function.