ARGS AND MORE

:[range]Bufdo[!] {cmd}  Execute {cmd} in each buffer in the buffer list, then
                        return back to the original one.
                        Any encountered errors are also put into the
                        quickfix list.

:[range]BufdoWrite {cmd}
                        Execute {cmd} in each modifiable buffer in the buffer
                        list and automatically persist any changes (:update).

:[range]Windo {cmd}     Execute {cmd} in each window, then return back to the
                        original one.
:[range]WindoWrite {cmd}
                        Execute {cmd} in each window showing a modifiable
                        buffer and automatically persist any changes (:update).

:[range]Winbufdo {cmd}  Execute {cmd} in each different buffer shown in one of
                        the windows in the current tab page (once per buffer),
                        then return back to the original one.
:[range]WinbufdoWrite {cmd}
                        Execute {cmd} in each different modifiable buffer
                        shown in one of the windows in the current tab page
                        (once per buffer) and automatically persist any
                        changes (:update).

:[range]Tabdo {cmd}     Execute {cmd} once in each tab page, then return back
                        to the original one.

:[range]Tabwindo {cmd}  Execute {cmd} in each open window on each tab page,
                        then return back to the original one.
:[range]TabwindoWrite {cmd}
                        Execute {cmd} in each open window on each tab page,
                        that shows a modifiable buffer and automatically
                        persist any changes (:update).

:[range]Argdo[!] {cmd}  Execute {cmd} for each file in the argument list, then
                        return back to the original file and argument.
                        [range] is emulated for older Vim versions, but can
                        only be used interactively (not in scripts).

                        In contrast to :argdo, this also avoids the
                        hit-enter prompt (all files will be processed
                        without further interaction from you), and an error
                        summary will be printed.
                        To work on the errors / arguments with errors, you can
                        use :ArgdoErrors and :ArgdoDeleteSuccessful.
                        Also, any encountered errors are put into the
                        quickfix list.

:[range]ArgdoWrite[!] {cmd}
                        Execute {cmd} in each modifiable buffer in the
                        argument list and automatically persist any changes
                        (:update).
:[range]ArgdoConfirmWrite[!] {cmd}
                        Like :ArgdoWrite, but confirm each write, allowing
                        to review the automatically applied changes of {cmd}
                        before persisting them. When you quit the argument
                        processing before the last argument, this will not
                        return to the original file (to make it easier to
                        process the remaining arguments again).

:ArgdoErrors            List all error messages that occurred during the last
                        :Argdo command, and for each unique error, print the
                        argument number and filespec.

:ArgdoDeleteSuccessful  Delete those arguments from the argument list that
                        didn't cause any error messages during the last
                        :Argdo command.

:[count]ArgMerge [{name} ...]
                        Add the {name}s to the argument list, but only if they
                        aren't yet contained in the argument list (:argadd
                        doesn't check and requires a follow-up deduplication).
                        When {name} is omitted add the current buffer name to
                        the argument list.

:[N]ArgDrop[!] [N]      Delete the current [N] argument(s) from the argument
                        list and edit the next one instead. Complains when the
                        current file is not contained in the argument list
                        unless [!] is given (which is also required to
                        abandon changes in the current buffer).

:[range]ArgsDeleteExisting[!]
                        Delete any files from the argument list that do (with
                        [!]: not) exist in the file system (actually: can[not]
                        be read).

:[range]ArgsDeleteFilesFromThisRoot[!]
                        Delete any files from the argument list that are (with
                        [!]: not) inside the current project root directory.

:[range]ArgsFilter[!] {expr}
                        Apply the filter() of {expr} to the files in the
                        argument list (i.e. values from argv(), referenced
                        as v:val), and keep only those where {expr} yields
                        true. This allows you to :argdelete multiple
                        arguments at once and to delete without specifying the
                        full filename.

:[range]ArgsFilterDo[!] {expr}
                        Apply the filter() of {expr} to the argument list
                        within the context of each argument, and keep only
                        those where {expr} yields true. In contrast to
                        :ArgsFilter, this allows filtering based on buffer
                        contents (or buffer variables, buffer settings).
                        For example, remove all arguments whose buffers have
                        more than 100 lines:
                            :ArgsFilterDo line('$') <= 100

:[range]ArgsKeepMatchingBuffers[!] [{pattern}]
                        Keep all arguments where {pattern} / the last search
                        pattern matches in the buffer.
:[range]ArgsDeleteMatchingBuffers[!] [{pattern}]
                        Delete all arguments where {pattern} / the last search
                        pattern matches in the buffer.

:[range]ArgsSort[!] [f][i][l][n][N]|{func-name}
                        Sort the argument list. [!] reverses the order; all
                        other arguments like sort().

:ArgsNegated[!] {arglist}
                        Define all files except {arglist} as the new argument
                        list and edit the first one.

:[range]ArgsList[!]     List each argument number, modification state, and
                        filespec in a neat list (not just one after the other
                        as :args). With [!], expand all arguments to
                        absolute filespecs.
:[range]ArgsList[!] {glob}
                        List each argument number, modification state, and
                        filespec that matches (with [!]: does not match)
                        {glob} in a neat list.
                        Matching and printing is done to the full filespec.

[count]<Leader>la       List each / the next [count] argument[s] (number,
                        modification state, and filespec) in a neat list.

:[range]ArgsToQuickfix  Show all arguments as a quickfix list.

:CListToArgs            Convert the files in the quickfix list to arguments.
:[count]CListToArgsAdd

:LListToArgs            Convert the files in the window's location list to
:[count]LListToArgsAdd  arguments.

:CList[!], :LList[!]    List each file that has listed errors in the quickfix
                        / location list in a neat list. With [!], expand all
                        to absolute filespecs.
:CList[!] {glob}        List each file that has listed errors in the quickfix
:LList[!] {glob}        / location list that matches (with [!]: does not
                        match) {glob} in a neat list. Matching and printing is
                        done to the full filespec.

:[range]CDoEntry {cmd}  Execute {cmd} on each entry in the quickfix /
:[range]LDoEntry {cmd}  location list (limited to buffers in [range]).

:[range]CDoFile {cmd}   Execute {cmd} once on each file that appears in the
:[range]LDoFile {cmd}   quickfix / location list (limited to buffers in
                        [range]).

:[range]CDoFixEntry {cmd}
:[range]LDoFixEntry {cmd}
                        Execute {cmd} on each entry in the quickfix / location
                        list (limited to buffers in [range]). If the {cmd}
                        does not abort and changes the buffer (i.e. increases
                        b:changedtick), that entry is removed from the
                        quickfix / location list. Else, the original entry is
                        augmented with error information. (Entries for buffers
                        outside [range] are kept as-is.)

vim ArgsAndMore*.vmb.gz
:so %

let g:ArgsAndMore_AfterCommand = 'update | sleep 100m'

let g:ArgsAndMore_InteractiveCommandPattern = '...'

nmap <Leader>la <Plug>(ArgsAndMoreList)