The builtin functions categorized

Neovim
1

@HiPhish informed me that categorization of the builtin functions exists in the docs :help function-list, and I came to the conclusion that the original post is unnecessary.

If you still want to read the original post then here it is:

The original post

I always wanted a list of the builtin functions being categorized so that I more easily could discover the function I needed for a particular task. So I made one:

Table of content

math

  • abs({expr}) Float or Number absolute value of {expr}
  • acos({expr}) Float arc cosine of {expr}
  • and({expr}, {expr}) Number bitwise AND
  • asin({expr}) Float arc sine of {expr}
  • atan({expr}) Float arc tangent of {expr}
  • atan2({expr1}, {expr2}) Float arc tangent of {expr1} / {expr2}
  • ceil({expr}) Float round {expr} up
  • cos({expr}) Float cosine of {expr}
  • cosh({expr}) Float hyperbolic cosine of {expr}
  • exp({expr}) Float exponential of {expr}
  • floor({expr}) Float round {expr} down
  • fmod({expr1}, {expr2}) Float remainder of {expr1} / {expr2}
  • invert({expr}) Number bitwise invert
  • log({expr}) Float natural logarithm (base e) of {expr}
  • log10({expr}) Float logarithm of Float {expr} to base 10
  • or({expr}, {expr}) Number bitwise OR
  • pow({x}, {y}) Float {x} to the power of {y}
  • round({expr}) Float round off {expr}
  • sin({expr}) Float sine of {expr}
  • sinh({expr}) Float hyperbolic sine of {expr}
  • sqrt({expr}) Float square root of {expr}
  • tan({expr}) Float tangent of {expr}
  • tanh({expr}) Float hyperbolic tangent of {expr}
  • trunc({expr}) Float truncate Float {expr}
  • xor({expr}, {expr}) Number bitwise XOR

assert

  • assert_beeps({cmd}) Number assert {cmd} causes a beep
  • assert_equal({exp}, {act} [, {msg}])
    Number assert {exp} is equal to {act}
  • assert_equalfile({fname-one}, {fname-two} [, {msg}])
    Number assert file contents are equal
  • assert_exception({error} [, {msg}])
    Number assert {error} is in v:exception
  • assert_fails({cmd} [, {error}]) Number assert {cmd} fails
  • assert_false({actual} [, {msg}])
    Number assert {actual} is false
  • assert_inrange({lower}, {upper}, {actual} [, {msg}])
    Number assert {actual} is inside the range
  • assert_match({pat}, {text} [, {msg}])
    Number assert {pat} matches {text}
  • assert_nobeep({cmd}) Number assert {cmd} does not cause a beep
  • assert_notequal({exp}, {act} [, {msg}])
    Number assert {exp} is not equal {act}
  • assert_notmatch({pat}, {text} [, {msg}])
    Number assert {pat} not matches {text}
  • assert_report({msg}) Number report a test failure
  • assert_true({actual} [, {msg}]) Number assert {actual} is true

string

  • soundfold({word}) String sound-fold {word}
  • iconv({expr}, {from}, {to}) String convert encoding of {expr}
  • strtrans({expr}) String translate string to make it printable
  • sha256({string}) String SHA256 checksum of {string}
  • substitute({expr}, {pat}, {sub}, {flags})
    String all {pat} in {expr} replaced with {sub}
  • strwidth({expr}) Number display cell length of the String {expr}
  • shellescape({string} [, {special}])
    String escape {string} for use as shell
    command argument
  • stridx({haystack}, {needle} [, {start}])
    Number index of {needle} in {haystack}
  • strridx({haystack}, {needle} [, {start}])
    Number last index of {needle} in {haystack}
  • charidx({string}, {idx} [, {countcc}])
    Number char index of byte {idx} in {string}
  • tolower({expr}) String the String {expr} switched to lowercase
  • string({expr}) String String representation of {expr} value
  • strlen({expr}) Number length of the String {expr}
  • strpart({str}, {start} [, {len} [, {chars}]])
    String {len} bytes/chars of {str} at
    byte {start}
  • strchars({expr} [, {skipcc}]) Number character length of the String {expr}
  • strcharpart({str}, {start} [, {len}])
    String {len} characters of {str} at
    character {start}
  • strdisplaywidth({expr} [, {col}]) Number display length of the String {expr}
  • strgetchar({str}, {index}) Number get char {index} from {str}
  • toupper({expr}) String the String {expr} switched to uppercase
  • escape({string}, {chars}) String escape {chars} in {string} with ''
  • split({expr} [, {pat} [, {keepempty}]])
    List make |List| from {pat} separated {expr}
  • tr({src}, {fromstr}, {tostr}) String translate chars of {src} in {fromstr}
    to chars in {tostr}
  • trim({text} [, {mask} [, {dir}]])
    String trim characters in {mask} from {text}

list

  • repeat({expr}, {count}) String repeat {expr} {count} times
  • range({expr} [, {max} [, {stride}]])
    List items from {expr} to {max}
  • add({object}, {item}) List/Blob append {item} to {object}
  • sort({list} [, {func} [, {dict}]])
    List sort {list}, using {func} to compare
  • join({list} [, {sep}]) String join {list} items into one String
  • uniq({list} [, {func} [, {dict}]])
    List remove adjacent duplicates from a list
  • flatten({list} [, {maxdepth}]) List flatten {list} up to {maxdepth} levels
  • max({expr}) Number maximum value of items in {expr}
  • reverse({list}) List reverse {list} in-place
  • min({expr}) Number minimum value of items in {expr}

lines

  • append({lnum}, {text}) Number append {text} below line {lnum}
  • appendbufline({expr}, {lnum}, {text})
    Number append {text} below line {lnum}
    in buffer {expr}
  • byte2line({byte}) Number line number at byte count {byte}
  • deletebufline({buf}, {first} [, {last}])
    Number delete lines from buffer {buf}
  • getbufline({buf}, {lnum} [, {end}])
    List lines {lnum} to {end} of buffer {buf}
  • getline({lnum}, {end}) List lines {lnum} to {end} of current buffer
  • line({expr} [, {winid}]) Number line nr of cursor, last line or mark
  • line2byte({lnum}) Number byte count of line {lnum}
  • nextnonblank({lnum}) Number line nr of non-blank line >= {lnum}
  • prevnonblank({lnum}) Number line nr of non-blank line <= {lnum}
  • setbufline({expr}, {lnum}, {text})
    Number set line {lnum} to {text} in buffer
    {expr}
  • setline({lnum}, {line}) Number set line {lnum} to {line}
  • winline() Number window line of the cursor

python

  • py3eval({expr}) any evaluate |python3| expression
  • pyeval({expr}) any evaluate |Python| expression
  • pyxeval({expr}) any evaluate |python_x| expression

lua

  • luaeval({expr} [, {expr}]) any evaluate |Lua| expression

job

  • jobpid({id}) Number Returns pid of a job.
  • jobresize({id}, {width}, {height})
    Number Resize pseudo terminal window of a job
  • jobstart({cmd} [, {opts}]) Number Spawns {cmd} as a job
  • jobstop({id}) Number Stops a job
  • jobwait({ids} [, {timeout}]) Number Wait for a set of jobs

dict

  • remove({dict}, {key}) any remove entry {key} from {dict}
  • items({dict}) List key-value pairs in {dict}
  • keys({dict}) List keys in {dict}
  • dictwatcheradd({dict}, {pattern}, {callback})
    Start watching a dictionary
  • values({dict}) List values in {dict}
  • dictwatcherdel({dict}, {pattern}, {callback})
    Stop watching a dictionary

dict/list

  • reduce({object}, {func} [, {initial}])
    any reduce {object} using {func}
  • index({object}, {expr} [, {start} [, {ic}]])
    Number index in {object} where {expr} appears
  • byteidx({expr}, {nr}) Number byte index of {nr}'th char in {expr}
  • byteidxcomp({expr}, {nr}) Number byte index of {nr}'th char in {expr}
  • insert({object}, {item} [, {idx}])
    List insert {item} in {object} [before {idx}]
  • count({comp}, {expr} [, {ic} [, {start}]])
    Number count how many {expr} are in {comp}
  • extend({expr1}, {expr2} [, {expr3}])
    List/Dict insert items of {expr2} into {expr1}
  • filter({expr1}, {expr2}) List/Dict remove items from {expr1} where
    {expr2} is 0
  • len({expr}) Number the length of {expr}
  • map({expr1}, {expr2}) List/Dict change each item in {expr1} to {expr}

buffer

  • bufadd({name}) Number add a buffer to the buffer list
  • bufexists({expr}) Number |TRUE| if buffer {expr} exists
  • buflisted({expr}) Number |TRUE| if buffer {expr} is listed
  • bufload({expr}) Number load buffer {expr} if not loaded yet
  • bufloaded({expr}) Number |TRUE| if buffer {expr} is loaded
  • bufname([{expr}]) String Name of the buffer {expr}
  • bufnr([{expr} [, {create}]]) Number Number of the buffer {expr}
  • bufwinid({expr}) Number |window-ID| of buffer {expr}
  • bufwinnr({expr}) Number window number of buffer {expr}
  • getbufinfo([{buf}]) List information about buffers
  • getbufvar({buf}, {varname} [, {def}])
    any variable {varname} in buffer {buf}
  • setbufvar({buf}, {varname}, {val}) set {varname} in buffer {buf} to {val}

window

  • wincol() Number window column of the cursor
  • winbufnr({nr}) Number buffer number of window {nr}
  • winheight({nr}) Number height of window {nr}
  • winlayout([{tabnr}]) List layout of windows in tab {tabnr}
  • winwidth({nr}) Number width of window {nr}
  • winrestcmd() String returns command to restore window sizes
  • setwinvar({nr}, {varname}, {val}) set {varname} in window {nr} to {val}
  • winsaveview() Dict save view of current window
  • winrestview({dict}) none restore view of current window
  • win_splitmove({nr}, {target} [, {options}])
    Number move window {nr} to split of {target}
  • win_screenpos({nr}) List get screen position of window {nr}
  • winnr([{expr}]) Number number of current window
  • win_move_statusline({nr}) Number move window status line
  • win_move_separator({nr}) Number move window vertical separator
  • win_id2win({expr}) Number get window nr from |window-ID|
  • win_id2tabwin({expr}) List get tab and window nr from |window-ID|
  • win_gotoid({expr}) Number go to |window-ID| {expr}
  • win_gettype([{nr}]) String type of window {nr}
  • win_getid([{win} [, {tab}]]) Number get |window-ID| for {win} in {tab}
  • win_findbuf({bufnr}) List find windows containing {bufnr}
  • win_execute({id}, {command} [, {silent}])
    String execute {command} in window {id}
  • getwininfo([{winid}]) List list of info about each window
  • getwinpos([{timeout}]) List X and Y coord in pixels of the Vim window
  • getwinposx() Number X coord in pixels of Vim window
  • getwinposy() Number Y coord in pixels of Vim window
  • getwinvar({nr}, {varname} [, {def}])
    any variable {varname} in window {nr}

arg-list

  • argv([-1, {winid}]) List the argument list
  • arglistid([{winnr} [, {tabnr}]]) Number argument list id
  • argidx() Number current index in the argument list
  • argc([{winid}]) Number number of files in the argument list

files and directorys

  • chdir({dir}) String change current working directory
  • getfperm({fname}) String file permissions of file {fname}
  • getfsize({fname}) Number size in bytes of file {fname}
  • getftype({fname}) String description of type of file {fname}
  • delete({fname} [, {flags}]) Number delete the file or directory {fname}
  • resolve({filename}) String get filename a shortcut points to
  • browse({save}, {title}, {initdir}, {default})
    String put up a file requester
  • filereadable({file}) Number |TRUE| if {file} is a readable file
  • finddir({name} [, {path} [, {count}]])
    String find directory {name} in {path}
  • readdir({dir} [, {expr}]) List file names in {dir} selected by {expr}
  • filewritable({file}) Number |TRUE| if {file} is a writable file
  • browsedir({title}, {initdir}) String put up a directory requester
  • mkdir({name} [, {path} [, {prot}]])
    Number create directory {name}
  • tempname() String name for a temporary file
  • rename({from}, {to}) Number rename (move) file from {from} to {to}
  • stdpath({what}) String/List returns the standard path(s) for {what}
  • getcwd([{winnr} [, {tabnr}]]) String get the current working directory
  • setfperm({fname}, {mode} Number set {fname} file permissions to {mode}
  • findfile({name} [, {path} [, {count}]])
    String find file {name} in {path}
  • writefile({object}, {fname} [, {flags}])
    Number write |Blob| or |List| of lines to file
  • readfile({fname} [, {type} [, {max}]])
    List get list of lines from file {fname}

filename

  • pathshorten({expr} [, {len}]) String shorten directory names in a path
  • simplify({filename}) String simplify filename as much as possible
  • fnameescape({fname}) String escape special characters in {fname}
  • fnamemodify({fname}, {mods}) String modify file name
  • exepath({expr}) String full path of the command {expr}
  • expand({expr} [, {nosuf} [, {list}]])
    any expand special keywords in {expr}

indent

  • cindent({lnum}) Number C indent for line {lnum}
  • indent({lnum}) Number indent of line {lnum}
  • lispindent({lnum}) Number Lisp indent for line {lnum}

column

  • charcol({expr}) Number column number of cursor or mark
  • col({expr}) Number column byte index of cursor or mark
  • screencol() Number current cursor column
  • virtcol({expr}) Number screen column of cursor or mark

screen

  • screenattr({row}, {col}) Number attribute at screen position
  • screenchar({row}, {col}) Number character at screen position
  • screenchars({row}, {col}) List List of characters at screen position
  • screenpos({winid}, {lnum}, {col}) Dict screen row and col of a text character
  • screenrow() Number current cursor row
  • screenstring({row}, {col}) String characters at screen position

timer

  • timer_info([{id}]) List information about timers
  • timer_pause({id}, {pause}) none pause or unpause a timer
  • timer_start({time}, {callback} [, {options}])
    Number create a timer
  • timer_stop({timer}) none stop a timer
  • timer_stopall() none stop all timers

complete

  • getcompletion({pat}, {type} [, {filtered}])
    List list of cmdline completion matches
  • complete({startcol}, {matches}) none set Insert mode completion
  • complete_add({expr}) Number add completion match
  • complete_check() Number check for key typed during completion
  • complete_info([{what}]) Dict get current completion information

convertion

  • list2str({list} [, {utf8}]) String turn numbers in {list} into a String
  • nr2char({expr} [, {utf8}]) String single char with ASCII/UTF-8 value {expr}
  • char2nr({expr} [, {utf8}]) Number ASCII/UTF-8 value of first char in {expr}
  • str2list({expr} [, {utf8}]) List convert each character of {expr} to
    ASCII/UTF-8 value
  • str2float({expr} [, {quoted}]) Float convert String to Float
  • str2nr({expr} [, {base} [, {quoted}]])
    Number convert String to Number
  • float2nr({expr}) Number convert Float {expr} to a Number

sign

  • sign_define({list}) List define or update a list of signs
  • sign_getdefined([{name}]) List get a list of defined signs
  • sign_getplaced([{buf} [, {dict}]])
    List get a list of placed signs
  • sign_jump({id}, {group}, {buf})
    Number jump to a sign
  • sign_place({id}, {group}, {name}, {buf} [, {dict}])
    Number place a sign
  • sign_placelist({list}) List place a list of signs
  • sign_undefine({list}) List undefine a list of signs
  • sign_unplace({group} [, {dict}])
    Number unplace a sign
  • sign_unplacelist({list}) List unplace a list of signs

tab

  • tabpagebuflist([{arg}]) List list of buffer numbers in tab page
  • tabpagenr([{arg}]) Number number of current or last tab page
  • tabpagewinnr({tabarg} [, {arg}])
    Number number of current window in tab page
  • settabvar({nr}, {varname}, {val}) set {varname} in tab page {nr} to {val}
  • gettabinfo([{expr}]) List list of tab pages
  • gettabvar({nr}, {varname} [, {def}])
    any variable {varname} in tab {nr} or {def}
  • gettabwinvar({tabnr}, {winnr}, {name} [, {def}])
    any {name} in {winnr} in tab page {tabnr}
  • settabwinvar({tabnr}, {winnr}, {varname}, {val}) set {varname} in window
    {winnr} in tab page {tabnr} to {val}

fold

  • foldclosed({lnum}) Number first line of fold at {lnum} if closed
  • foldclosedend({lnum}) Number last line of fold at {lnum} if closed
  • foldlevel({lnum}) Number fold level at {lnum}
  • foldtext() String line displayed for closed fold
  • foldtextresult({lnum}) String text for closed fold at {lnum}

context

  • ctxget([{index}]) Dict return the |context| dict at {index}
  • ctxpop() none pop and restore |context| from the
    |context-stack|
  • ctxpush([{types}]) none push the current |context| to the
    |context-stack|
  • ctxset({context} [, {index}]) none set |context| at {index}
  • ctxsize() Number return |context-stack| size

match

  • match({expr}, {pat} [, {start} [, {count}]])
    Number position where {pat} matches in {expr}
  • matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]])
    Number highlight {pattern} with {group}
  • matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]])
    Number highlight positions with {group}
  • matcharg({nr}) List arguments of |:match|
  • matchdelete({id} [, {win}]) Number delete match identified by {id}
  • submatch({nr} [, {list}]) String or List
    specific match in “:s” or substitute()
  • clearmatches([{win}]) none clear all matches
  • getmatches([{win}]) List list of current matches
  • matchend({expr}, {pat} [, {start} [, {count}]])
    Number position where {pat} ends in {expr}
  • matchfuzzy({list}, {str} [, {dict}])
    List fuzzy match {str} in {list}
  • matchfuzzypos({list}, {str} [, {dict}])
    List fuzzy match {str} in {list}
  • matchlist({expr}, {pat} [, {start} [, {count}]])
    List match and submatches of {pat} in {expr}
  • matchstr({expr}, {pat} [, {start} [, {count}]])
    String {count}'th match of {pat} in {expr}
  • setmatches({list} [, {win}]) Number restore a list of matches
  • matchstrpos({expr}, {pat} [, {start} [, {count}]])
    List {count}'th match of {pat} in {expr}

cmd-line

  • getcmdcompltype() String return the type of the current
    command-line completion
  • setcmdpos({pos}) Number set cursor position in command-line
  • getcmdline() String return the current command-line
  • getcmdpos() Number return cursor position in command-line
  • getcmdscreenpos() Number return cursor screen position in
    command-line
  • getcmdtype() String return current command-line type
  • getcmdwintype() String return current command-line window type

search

  • setcharsearch({dict}) Dict set character search from {dict}
  • search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
    Number search for {pattern}
  • searchcount([{options}]) Dict Get or update the last search count
  • searchdecl({name} [, {global} [, {thisblock}]])
    Number search for variable declaration
  • getcharsearch() Dict last character search
  • searchpair({start}, {middle}, {end} [, {flags} [, {skip} […]]])
    Number search for other end of start/end pair
  • searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} […]]])
    List search for other end of start/end pair
  • searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]])
    List search for {pattern}

pos

  • setcharpos({expr}, {list}) Number set the {expr} position to {list}
  • getcharpos({expr}) List position of cursor, mark, etc.
  • getcurpos([{winnr}]) List position of the cursor
  • getcursorcharpos([{winnr}]) List character position of the cursor
  • setpos({expr}, {list}) Number set the {expr} position to {list}
  • getpos({expr}) List position of cursor, mark, etc.
  • getmousepos() Dict last known mouse position
  • cursor({list}) Number move cursor to position in {list}
  • setcursorcharpos({list}) Number move cursor to position in {list}

time

  • strftime({format} [, {time}]) String format time with a specified format
  • strptime({format}, {timestring})
    Number Convert {timestring} to unix timestamp
  • getftime({fname}) Number last modification time of file
  • localtime() Number current time
  • reltime([{start} [, {end}]]) List get time value
  • reltimefloat({time}) Float turn the time value into a Float
  • reltimestr({time}) String turn time value into a String

condition test

  • has({feature}) Number |TRUE| if feature {feature} supported
  • has_key({dict}, {key}) Number |TRUE| if {dict} has entry {key}
  • haslocaldir([{winnr} [, {tabnr}]])
    Number |TRUE| if the window executed |:lcd| or
    the tab executed |:tcd|
  • did_filetype() Number |TRUE| if FileType autocommand event used
  • empty({expr}) Number |TRUE| if {expr} is empty
  • eventhandler() Number |TRUE| if inside an event handler
  • exists({expr}) Number |TRUE| if {expr} exists
  • hlexists({name}) Number |TRUE| if highlight group {name} exists
  • islocked({expr}) Number |TRUE| if {expr} is locked
  • isnan({expr}) Number |TRUE| if {expr} is NaN
  • isdirectory({directory}) Number |TRUE| if {directory} is a directory
  • isinf({expr}) Number determine if {expr} is infinity value
    (positive or negative)

map

  • maparg({name} [, {mode} [, {abbr} [, {dict}]]])
    String or Dict
    rhs of mapping {name} in mode {mode}
  • mapcheck({name} [, {mode} [, {abbr}]])
    String check for mappings matching {name}
  • hasmapto({what} [, {mode} [, {abbr}]])
    Number |TRUE| if mapping to {what} exists

api

  • nvim_…({args}…) any call nvim |api| functions
  • api_info() Dict api metadata

digraph

  • digraph_get({chars}) String get the digraph of {chars}
  • digraph_getlist([{listall}]) List get all |digraph|s
  • digraph_set({chars}, {digraph}) Boolean register |digraph|
  • digraph_setlist({digraphlist}) Boolean register multiple |digraph|s

swap

  • swapinfo({fname}) Dict information about swap file {fname}
  • swapname({buf}) String swap file of buffer {buf}

syntax

  • hlID({name}) Number syntax ID of highlight group {name}
  • synID({lnum}, {col}, {trans}) Number syntax ID at {lnum} and {col}
  • synstack({lnum}, {col}) List stack of syntax IDs at {lnum} and {col}
  • synIDattr({synID}, {what} [, {mode}])
    String attribute {what} of syntax ID {synID}
  • synIDtrans({synID}) Number translated syntax ID of {synID}

spec-lists

  • serverlist() String get a list of available servers
  • setloclist({nr}, {list}, {action}, {what})
    Number modify specific location list props
  • setqflist({list}, {action}, {what})
    Number modify specific quickfix list props
  • getjumplist([{winnr} [, {tabnr}]])
    List list of jump list items
  • getloclist({nr}, {what}) Dict get specific location list properties
  • getmarklist([{buf}]) List list of global/local marks
  • getqflist({what}) Dict get specific quickfix list properties

input

  • input({prompt} [, {text} [, {completion}]])
    String get input from the user
  • getcharmod() Number modifiers for the last typed character
  • getcharstr([expr]) String get one character from the user
  • inputlist({textlist}) Number let the user pick from a choice list
  • inputrestore() Number restore typeahead
  • inputsave() Number save and clear typeahead
  • inputsecret({prompt} [, {text}])
    String like input() but hiding the text
  • confirm({msg} [, {choices} [, {default} [, {type}]]])
    Number number of choice picked by user
  • getchar([expr]) Number or String
    get one character from the user

channel

  • chanclose({id} [, {stream}]) Number Closes a channel or one of its streams
  • rpcnotify({channel}, {event} [, {args}…])
    Sends an |RPC| notification to {channel}
  • rpcrequest({channel}, {method} [, {args}…])
    Sends an |RPC| request to {channel}
  • chansend({id}, {data}) Number Writes {data} to channel

history

  • histadd({history}, {item}) String add an item to a history
  • histdel({history} [, {item}]) String remove an item from a history
  • histget({history} [, {index}]) String get the item {index} from a history
  • histnr({history}) Number highest index of a history

tag

  • taglist({expr} [, {filename}]) List list of tags matching {expr}
  • gettagstack([{nr}]) Dict get the tag stack of window {nr}
  • settagstack({nr}, {dict} [, {action}])
    Number modify tag stack using {dict}
  • tagfiles() List tags files used

expr

  • copy({expr}) any make a shallow copy of {expr}
  • deepcopy({expr} [, {noref}]) any make a full copy of {expr}
  • id({expr}) String identifier of the container
  • type({name}) Number type of variable {name}

prompt

  • prompt_getprompt({buf}) String get prompt text
  • prompt_setcallback({buf}, {expr}) none set prompt callback function
  • prompt_setinterrupt({buf}, {text}) none set prompt interrupt function
  • prompt_setprompt({buf}, {text}) none set prompt text

pum

  • pum_getpos() Dict position and size of pum if visible
  • pumvisible() Number whether popup menu is visible

random

  • rand([{expr}]) Number get pseudo-random number
  • srand([{expr}]) List get seed for |rand()|

reg

  • reg_executing() String get the executing register name
  • setreg({n}, {v} [, {opt}]) Number set register to value and type
  • getreg([{regname} [, 1 [, {list}]]])
    String or List contents of a register
  • getreginfo([{regname}]) Dict information about a register
  • getregtype([{regname}]) String type of a register
  • reg_recorded() String get the last recorded register name
  • reg_recording() String get the recording register name

shell

  • system({cmd} [, {input}]) String output of shell command/filter {cmd}
  • systemlist({cmd} [, {input}]) List output of shell command/filter {cmd}

spell

  • spellbadword() String badly spelled word at cursor
  • spellsuggest({word} [, {max} [, {capital}]])
    List spelling suggestions

env

  • environ() Dict return environment variables
  • getenv({name}) String return environment variable
  • setenv({name}, {val}) none set environment variable

function

  • funcref({name} [, {arglist}] [, {dict}])
    Funcref reference to function {name}
  • function({name} [, {arglist}] [, {dict}])
    Funcref named reference to function {name}
  • call({func}, {arglist} [, {dict}])
    any call {func} with arguments {arglist}

system info

  • hostname() String name of the machine Vim is running on
  • windowsversion() String MS-Windows OS version

undo

  • undofile({name}) String undo file name for {name}
  • undotree() List undo file tree

json

  • json_decode({expr}) any Convert {expr} from JSON
  • json_encode({expr}) String Convert {expr} to JSON

msgpack

  • msgpackdump({list} [, {type}]) List/Blob dump objects to msgpack
  • msgpackparse({data}) List parse msgpack to a list of objects

lib

  • libcall({lib}, {func}, {arg}) String call {func} in library {lib} with {arg}
  • libcallnr({lib}, {func}, {arg}) Number idem, but return a Number

get

  • getpid() Number process ID of Vim
  • getfontname([{name}]) String name of font being used
  • get({func}, {what}) any get property of funcref/partial {func}
  • menu_get({path} [, {modes}]) List description of |menus| matched by {path}
  • shiftwidth([{col}]) Number effective value of ‘shiftwidth’
  • mode([expr]) String current editing mode

diff

  • diff_filler({lnum}) Number diff filler lines about {lnum}
  • diff_hlID({lnum}, {col}) Number diff highlighting at {lnum}/{col}

change

  • getchangelist([{buf}]) List list of change list items
  • changenr() Number current change number

eval

  • perleval({expr}) any evaluate |perl| expression
  • rubyeval({expr}) any evaluate |Ruby| expression
  • eval({string}) any evaluate {string} into its value
  • executable({expr}) Number 1 if executable {expr} exists
  • execute({command}) String execute and capture output of {command}

glob

  • glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
    any expand file wildcards in {expr}
  • glob2regpat({expr}) String convert a glob pat into a search pat
  • globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]])
    String do glob({expr}) for all dirs in {path}

debig

  • debugbreak({pid}) Number interrupt process being debugged
  • test_garbagecollect_now() none free memory right now for testing
  • interrupt() none interrupt script execution

other

  • wait({timeout}, {condition} [, {interval}])
    Number Wait until {condition} is satisfied
  • wordcount() Dict get byte/char/word statistics
  • sockconnect({mode}, {address} [, {opts}])
    Number Connects to socket
  • printf({fmt}, {expr1}…) String format text
  • stdioopen({dict}) Number open stdio in a headless instance.
  • garbagecollect([{atexit}]) none free memory, breaking cyclic references
  • synconcealed({lnum}, {col}) List info about concealing
  • visualmode([expr]) String last visual mode used
  • wildmenumode() Number whether ‘wildmenu’ mode is active
  • cscope_connection([{num}, {dbpath} [, {prepend}]])
    Number checks existence of cscope connection
  • expandcmd({expr}) String expand {expr} like with :edit
  • fullcommand({name}) String get full command from {name}
  • feedkeys({string} [, {mode}]) Number add key sequence to typeahead buffer
6 Likes
2

What about :h function-list? It already has a list of all functions grouped by category with description. And since it’s built-in you can C-] on a function name to jump to the detailed documentation.