fn | /deps.ts | ddc_vim@v4.3.1

namespace fn

import { fn } from "https://deno.land/x/ddc_vim@v4.3.1/deps.ts";

A module to provide functions of Vim and Neovim native functions.

import { Denops } from "../mod.ts";
import * as fn from "../function/mod.ts";

export async function main(denops: Denops): Promise<void> {
  // fn holds functions exists in both Vim and Neovim
  console.log(fn.or(denops, 0, 1));
}

See vim/mod.ts or nvim/mod.ts if you need Vim or Neovim specific functions.

Functions

f fn.abs	Return the absolute value of {expr}. When {expr} evaluates to a `Float` abs() returns a `Float`. When {expr} can be converted to a `Number` abs() returns a `Number`. Otherwise abs() gives an error message and returns -1. Examples:
f fn.acos	Return the arc cosine of {expr} measured in radians, as a `Float` in the range of [0, pi]. {expr} must evaluate to a `Float` or a `Number` in the range [-1, 1]. Otherwise acos() returns "nan". Examples:
f fn.add	Append the item {expr} to `List` or `Blob` {object}. Returns the resulting `List` or `Blob`. Examples:
f fn.and	Bitwise AND on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Also see `or()` and `xor()`. Example:
f fn.append
f fn.appendbufline	Like `append()` but append the text in buffer {buf}.
f fn.argc	The result is the number of files in the argument list. See `arglist`. If {winid} is not supplied, the argument list of the current window is used. If {winid} is -1, the global argument list is used. Otherwise {winid} specifies the window of which the argument list is used: either the window number or the window ID. Returns -1 if the {winid} argument is invalid.
f fn.argidx	The result is the current index in the argument list. 0 is the first file. argc() - 1 is the last one. See `arglist`.
f fn.arglistid	Return the argument list ID. This is a number which identifies the argument list being used. Zero is used for the global argument list. See `arglist`. Returns -1 if the arguments are invalid.
f fn.argv	The result is the {nr}th file in the argument list. See `arglist`. "argv(0)" is the first one. Example:
f fn.asin	Return the arc sine of {expr} measured in radians, as a `Float` in the range of [-pi/2, pi/2]. {expr} must evaluate to a `Float` or a `Number` in the range [-1, 1]. Returns "nan" if {expr} is outside the range [-1, 1]. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.assertPosition	Assert if `x` is Position by raising an `AssertError` when it's not.
f fn.assertScreenPos	Assert if `x` is ScreenPos by raising an `AssertError` when it's not.
f fn.atan	Return the principal value of the arc tangent of {expr}, in the range [-pi/2, +pi/2] radians, as a `Float`. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.atan2	Return the arc tangent of {expr1} / {expr2}, measured in radians, as a `Float` in the range [-pi, pi]. {expr1} and {expr2} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr1} or {expr2} is not a `Float` or a `Number`. Examples:
f fn.browse	Put up a file requester. This only works when "has("browse")" returns `TRUE` (only in some GUI versions). The input fields are: {save} when `TRUE`, select file to write {title} title for the requester {initdir} directory to start browsing in {default} default file name An empty string is returned when the "Cancel" button is hit, something went wrong, or browsing is not possible.
f fn.browsedir	Put up a directory requester. This only works when "has("browse")" returns `TRUE` (only in some GUI versions). On systems where a directory browser is not supported a file browser is used. In that case: select a file in the directory to be used. The input fields are: {title} title for the requester {initdir} directory to start browsing in When the "Cancel" button is hit, something went wrong, or browsing is not possible, an empty string is returned.
f fn.bufadd	Add a buffer to the buffer list with name {name} (must be a String). If a buffer for file {name} already exists, return that buffer number. Otherwise return the buffer number of the newly created buffer. When {name} is an empty string then a new buffer is always created. The buffer will not have 'buflisted' set and not be loaded yet. To add some text to the buffer use this:
f fn.bufexists	The result is a Number, which is `TRUE` if a buffer called {buf} exists. If the {buf} argument is a number, buffer numbers are used. Number zero is the alternate buffer for the current window.
f fn.buflisted	The result is a Number, which is `TRUE` if a buffer called {buf} exists and is listed (has the 'buflisted' option set). The {buf} argument is used like with `bufexists()`.
f fn.bufload	Ensure the buffer {buf} is loaded. When the buffer name refers to an existing file then the file is read. Otherwise the buffer will be empty. If the buffer was already loaded then there is no change. If the buffer is not related to a file the no file is read (e.g., when 'buftype' is "nofile"). If there is an existing swap file for the file of the buffer, there will be no dialog, the buffer will be loaded anyway. The {buf} argument is used like with `bufexists()`.
f fn.bufloaded	The result is a Number, which is `TRUE` if a buffer called {buf} exists and is loaded (shown in a window or hidden). The {buf} argument is used like with `bufexists()`.
f fn.bufname	The result is the name of a buffer. Mostly as it is displayed by the `:ls` command, but not using special names such as "[No Name]". If {buf} is omitted the current buffer is used. If {buf} is a Number, that buffer number's name is given. Number zero is the alternate buffer for the current window. If {buf} is a String, it is used as a `file-pattern` to match with the buffer names. This is always done like 'magic' is set and 'cpoptions' is empty. When there is more than one match an empty string is returned. "" or "%" can be used for the current buffer, "#" for the alternate buffer. A full match is preferred, otherwise a match at the start, end or middle of the buffer name is accepted. If you only want a full match then put "^" at the start and "$" at the end of the pattern. Listed buffers are found first. If there is a single match with a listed buffer, that one is returned. Next unlisted buffers are searched for. If the {buf} is a String, but you want to use it as a buffer number, force it to be a Number by adding zero to it:
f fn.bufnr	The result is the number of a buffer, as it is displayed by the `:ls` command. For the use of {buf}, see `bufname()` above.
f fn.bufwinid	The result is a Number, which is the `window-ID` of the first window associated with buffer {buf}. For the use of {buf}, see `bufname()` above. If buffer {buf} doesn't exist or there is no such window, -1 is returned. Example:
f fn.bufwinnr	Like `bufwinid()` but return the window number instead of the `window-ID`. If buffer {buf} doesn't exist or there is no such window, -1 is returned. Example:
f fn.byte2line	Return the line number that contains the character at byte count {byte} in the current buffer. This includes the end-of-line character, depending on the 'fileformat' option for the current buffer. The first character has byte count one. Also see `line2byte()`, `go` and `:goto`.
f fn.byteidx
f fn.byteidxcomp	Like byteidx(), except that a composing character is counted as a separate character. Example:
f fn.call	Call function {func} with the items in `List` {arglist} as arguments. {func} can either be a `Funcref` or the name of a function. a:firstline and a:lastline are set to the cursor line. Returns the return value of the called function. {dict} is for functions with the "dict" attribute. It will be used to set the local variable "self". `Dictionary-function`
f fn.ceil	Return the smallest integral value greater than or equal to {expr} as a `Float` (round up). {expr} must evaluate to a `Float` or a `Number`. Examples:
f fn.changenr	Return the number of the most recent change. This is the same number as what is displayed with `:undolist` and can be used with the `:undo` command. When a change was made it is the number of that change. After redo it is the number of the redone change. After undo it is one less than the number of the undone change. Returns 0 if the undo list is empty.
f fn.char2nr
f fn.charclass	Return the character class of the first character in {string}. The character class is one of: 0 blank 1 punctuation 2 word character 3 emoji other specific Unicode class The class is used in patterns and word motions. Returns 0 if {string} is not a `String`.
f fn.charcol	Same as `col()` but returns the character index of the column position given with {expr} instead of the byte position.
f fn.charidx
f fn.chdir	Change the current working directory to {dir}. The scope of the directory change depends on the directory of the current window: - If the current window has a window-local directory (`:lcd`), then changes the window local directory. - Otherwise, if the current tabpage has a local directory (`:tcd`) then changes the tabpage local directory. - Otherwise, changes the global directory. {dir} must be a String. If successful, returns the previous working directory. Pass this to another chdir() to restore the directory. On failure, returns an empty string.
f fn.cindent	Get the amount of indent for line {lnum} according the C indenting rules, as with 'cindent'. The indent is counted in spaces, the value of 'tabstop' is relevant. {lnum} is used just like in `getline()`. When {lnum} is invalid -1 is returned. See `C-indenting`.
f fn.clearmatches	Clears all matches previously defined for the current window by `matchadd()` and the `:match` commands. If {win} is specified, use the window with this number or window ID instead of the current window.
f fn.col	The result is a Number, which is the byte index of the column position given with {expr}. The accepted positions are: . the cursor position $ the end of the cursor line (the result is the number of bytes in the cursor line plus one) 'x position of mark x (if the mark is not set, 0 is returned) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from `'<` in that it's updated right away. Additionally {expr} can be [lnum, col]: a `List` with the line and column number. Most useful when the column is "$", to get the last column of a specific line. When "lnum" or "col" is out of range then col() returns zero. With the optional {winid} argument the values are obtained for that window instead of the current window. To get the line number use `line()`. To get both use `getpos()`. For the screen column position use `virtcol()`. For the character position use `charcol()`. Note that only marks in the current file can be used. Examples:
f fn.complete
f fn.complete_add	Add {expr} to the list of matches. Only to be used by the function specified with the 'completefunc' option. Returns 0 for failure (empty string or out of memory), 1 when the match was added, 2 when the match was already in the list. See `complete-functions` for an explanation of {expr}. It is the same as one item in the list that 'omnifunc' would return.
f fn.complete_check	Check for a key typed while looking for completion matches. This is to be used when looking for matches takes some time. Returns `TRUE` when searching for matches is to be aborted, zero otherwise. Only to be used by the function specified with the 'completefunc' option.
f fn.complete_info
f fn.confirm
f fn.copy	Make a copy of {expr}. For Numbers and Strings this isn't different from using {expr} directly. When {expr} is a `List` a shallow copy is created. This means that the original `List` can be changed without changing the copy, and vice versa. But the items are identical, thus changing an item changes the contents of both `Lists`. A `Dictionary` is copied in a similar way as a `List`. Also see `deepcopy()`. Can also be used as a `method`:
f fn.cos	Return the cosine of {expr}, measured in radians, as a `Float`. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.cosh	Return the hyperbolic cosine of {expr} as a `Float` in the range [1, inf]. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.count
f fn.cscope_connection
f fn.cursor
f fn.debugbreak	Specifically used to interrupt a program being debugged. It will cause process {pid} to get a SIGTRAP. Behavior for other processes is undefined. See `terminal-debugger`. only available on MS-Windows
f fn.deepcopy
f fn.delete_
f fn.deletebufline	Delete lines {first} to {last} (inclusive) from buffer {buf}. If {last} is omitted then delete line {first} only. On success 0 is returned, on failure 1 is returned.
f fn.did_filetype	Returns `TRUE` when autocommands are being executed and the FileType event has been triggered at least once. Can be used to avoid triggering the FileType event again in the scripts that detect the file type. `FileType` Returns `FALSE` when `:setf FALLBACK` was used. When editing another file, the counter is reset, thus this really checks if the FileType event has been triggered for the current buffer. This allows an autocommand that starts editing another buffer to set 'filetype' and load a syntax file.
f fn.diff_filler	Returns the number of filler lines above line {lnum}. These are the lines that were inserted at this point in another diff'ed window. These filler lines are shown in the display but don't exist in the buffer. {lnum} is used like with `getline()`. Thus "." is the current line, "'m" mark m, etc. Returns 0 if the current window is not in diff mode.
f fn.diff_hlID	Returns the highlight ID for diff mode at line {lnum} column {col} (byte index). When the current line does not have a diff change zero is returned. {lnum} is used like with `getline()`. Thus "." is the current line, "'m" mark m, etc. {col} is 1 for the leftmost column, {lnum} is 1 for the first line. The highlight ID can be used with `synIDattr()` to obtain syntax information about the highlighting.
f fn.digraph_get
f fn.digraph_getlist	Return a list of digraphs. If the {listall} argument is given and it is TRUE, return all digraphs, including the default digraphs. Otherwise, return only user-defined digraphs.
f fn.digraph_set
f fn.digraph_setlist	Similar to `digraph_set()` but this function can add multiple digraphs at once. {digraphlist} is a list composed of lists, where each list contains two strings with {chars} and {digraph} as in `digraph_set()`. Example:
f fn.empty	Return the Number 1 if {expr} is empty, zero otherwise. A `List` or `Dictionary` is empty when it does not have any items. A `String` is empty when its length is zero. A `Number` and `Float` are empty when their value is zero. `v:false`, `v:none` and `v:null` are empty, `v:true` is not. A `Job` is empty when it failed to start. A `Channel` is empty when it is closed. A `Blob` is empty when its length is zero.
f fn.environ	Return all of environment variables as dictionary. You can check if an environment variable exists like this:
f fn.escape	Escape the characters in {chars} that occur in {string} with a backslash. Example:
f fn.eval_	Evaluate {string} and return the result. Especially useful to turn the result of `string()` back into the original value. This works for Numbers, Floats, Strings, Blobs and composites of them. Also works for `Funcref`s that refer to existing functions.
f fn.eventhandler	Returns 1 when inside an event handler. That is that Vim got interrupted while waiting for the user to type a character, e.g., when dropping a file on Vim. This means interactive commands cannot be used. Otherwise zero is returned.
f fn.executable
f fn.execute
f fn.exepath	If {expr} is an executable and is either an absolute path, a relative path or found in $PATH, return the full path. Note that the current directory is used when {expr} starts with "./", which may be a problem for Vim:
f fn.exists	The result is a Number, which is `TRUE` if {expr} is defined, zero otherwise.
f fn.exp	Return the exponential of {expr} as a `Float` in the range [0, inf]. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.expand
f fn.expandcmd
f fn.extend
f fn.feedkeys
f fn.filereadable	The result is a Number, which is `TRUE` when a file with the name {file} exists, and can be read. If {file} doesn't exist, or is a directory, the result is `FALSE`. {file} is any expression, which is used as a String. If you don't care about the file being readable you can use `glob()`. {file} is used as-is, you may want to expand wildcards first:
f fn.filewritable	The result is a Number, which is 1 when a file with the name {file} exists, and can be written. If {file} doesn't exist, or is not writable, the result is 0. If {file} is a directory, and we can write to it, the result is 2.
f fn.filter
f fn.finddir
f fn.findfile	Just like `finddir()`, but find a file instead of a directory. Uses 'suffixesadd'. Example:
f fn.flatten
f fn.float2nr
f fn.floor	Return the largest integral value less than or equal to {expr} as a `Float` (round down). {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.fmod	Return the remainder of {expr1} / {expr2}, even if the division is not representable. Returns {expr1} - i * {expr2} for some integer i such that if {expr2} is non-zero, the result has the same sign as {expr1} and magnitude less than the magnitude of {expr2}. If {expr2} is zero, the value returned is zero. The value returned is a `Float`. {expr1} and {expr2} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr1} or {expr2} is not a `Float` or a `Number`. Examples:
f fn.fnameescape	Escape {string} for use as file name command argument. All characters that have a special meaning, such as '%' and '\|' are escaped with a backslash. For most systems the characters escaped are " \t\n*?[{`$\\%#'\"\|!<". For systems where a backslash appears in a filename, it depends on the value of 'isfname'. A leading '+' and '>' is also escaped (special after `:edit` and `:write`). And a "-" by itself (special after `:cd`). Returns an empty string on error. Example:
f fn.fnamemodify
f fn.foldclosed	The result is a Number. If the line {lnum} is in a closed fold, the result is the number of the first line in that fold. If the line {lnum} is not in a closed fold, -1 is returned. {lnum} is used like with `getline()`. Thus "." is the current line, "'m" mark m, etc.
f fn.foldclosedend	The result is a Number. If the line {lnum} is in a closed fold, the result is the number of the last line in that fold. If the line {lnum} is not in a closed fold, -1 is returned. {lnum} is used like with `getline()`. Thus "." is the current line, "'m" mark m, etc.
f fn.foldlevel	The result is a Number, which is the foldlevel of line {lnum} in the current buffer. For nested folds the deepest level is returned. If there is no fold at line {lnum}, zero is returned. It doesn't matter if the folds are open or closed. When used while updating folds (from 'foldexpr') -1 is returned for lines where folds are still to be updated and the foldlevel is unknown. As a special case the level of the previous line is usually available. {lnum} is used like with `getline()`. Thus "." is the current line, "'m" mark m, etc.
f fn.foldtext	Returns a String, to be displayed for a closed fold. This is the default function used for the 'foldtext' option and should only be called from evaluating 'foldtext'. It uses the `v:foldstart`, `v:foldend` and `v:folddashes` variables. The returned string looks like this:
f fn.foldtextresult	Returns the text that is displayed for the closed fold at line {lnum}. Evaluates 'foldtext' in the appropriate context. When there is no closed fold at {lnum} an empty string is returned. {lnum} is used like with `getline()`. Thus "." is the current line, "'m" mark m, etc. Useful when exporting folded text, e.g., to HTML. not available when compiled without the `+folding` feature
f fn.fullcommand
f fn.funcref	Just like `function()`, but the returned Funcref will lookup the function by reference, not by name. This matters when the function {name} is redefined later.
f fn.function_
f fn.garbagecollect
f fn.get	Get item {idx} from `List` {list}. When this item is not available return {default}. Return zero when {default} is omitted. Preferably used as a `method`:
f fn.getbufinfo
f fn.getbufline	Return a `List` with the lines starting from {lnum} to {end} (inclusive) in the buffer {buf}. If {end} is omitted, a `List` with only the line {lnum} is returned. See `getbufoneline()` for only getting the line.
f fn.getbufvar
f fn.getchangelist	Returns the `changelist` for the buffer {buf}. For the use of {buf}, see `bufname()` above. If buffer {buf} doesn't exist, an empty list is returned.
f fn.getchar
f fn.getcharmod	The result is a Number which is the state of the modifiers for the last obtained character with getchar() or in another way. These values are added together: 2 shift 4 control 8 alt (meta) 16 meta (when it's different from ALT) 32 mouse double click 64 mouse triple click 96 mouse quadruple click (== 32 + 64) 128 command (Macintosh only) Only the modifiers that have not been included in the character itself are obtained. Thus Shift-a results in "A" without a modifier. Returns 0 if no modifiers are used.
f fn.getcharpos	Get the position for String {expr}. Same as `getpos()` but the column number in the returned List is a character index instead of a byte index. If `getpos()` returns a very large column number, equal to `v:maxcol`, then getcharpos() will return the character index of the last character.
f fn.getcharsearch
f fn.getcharstr	Get a single character from the user or input stream as a string. If [expr] is omitted, wait until a character is available. If [expr] is 0 or false, only get a character when one is available. Return an empty string otherwise. If [expr] is 1 or true, only check if a character is available, it is not consumed. Return an empty string if no character is available. Otherwise this works like `getchar()`, except that a number result is converted to a string.
f fn.getcmdcompltype	Return the type of the current command-line completion. Only works when the command line is being edited, thus requires use of `c_CTRL-\_e` or `c_CTRL-R_=`. See `:command-completion` for the return string. Also see `getcmdtype()`, `setcmdpos()`, `getcmdline()` and `setcmdline()`. Returns an empty string when completion is not defined.
f fn.getcmdline	Return the current command-line. Only works when the command line is being edited, thus requires use of `c_CTRL-\_e` or `c_CTRL-R_=`. Example:
f fn.getcmdpos	Return the position of the cursor in the command line as a byte count. The first column is 1. Only works when editing the command line, thus requires use of `c_CTRL-\_e` or `c_CTRL-R_=` or an expression mapping. Returns 0 otherwise. Also see `getcmdtype()`, `setcmdpos()`, `getcmdline()` and `setcmdline()`.
f fn.getcmdscreenpos	Return the screen position of the cursor in the command line as a byte count. The first column is 1. Instead of `getcmdpos()`, it adds the prompt position. Only works when editing the command line, thus requires use of `c_CTRL-\_e` or `c_CTRL-R_=` or an expression mapping. Returns 0 otherwise. Also see `getcmdpos()`, `setcmdpos()`, `getcmdline()` and `setcmdline()`.
f fn.getcmdtype	Return the current command-line type. Possible return values are: : normal Ex command > debug mode command `debug-mode` / forward search command ? backward search command @ `input()` command - `:insert` or `:append` command = `i_CTRL-R_=` Only works when editing the command line, thus requires use of `c_CTRL-\_e` or `c_CTRL-R_=` or an expression mapping. Returns an empty string otherwise. Also see `getcmdpos()`, `setcmdpos()` and `getcmdline()`.
f fn.getcmdwintype	Return the current `command-line-window` type. Possible return values are the same as `getcmdtype()`. Returns an empty string when not in the command-line window.
f fn.getcompletion
f fn.getcurpos	Get the position of the cursor. This is like getpos('.'), but includes an extra "curswant" item in the list: [0, lnum, col, off, curswant] The "curswant" number is the preferred column when moving the cursor vertically. After `$` command it will be a very large number equal to `v:maxcol`. Also see `getcursorcharpos()` and `getpos()`. The first "bufnum" item is always zero. The byte position of the cursor is returned in 'col'. To get the character position, use `getcursorcharpos()`.
f fn.getcursorcharpos	Same as `getcurpos()` but the column number in the returned List is a character index instead of a byte index.
f fn.getcwd
f fn.getenv	Return the value of environment variable {name}. The {name} argument is a string, without a leading '$'. Example:
f fn.getfontname	Without an argument returns the name of the normal font being used. Like what is used for the Normal highlight group `hl-Normal`. With an argument a check is done whether String {name} is a valid font name. If not then an empty string is returned. Otherwise the actual font name is returned, or {name} if the GUI does not support obtaining the real name. Only works when the GUI is running, thus not in your vimrc or gvimrc file. Use the `GUIEnter` autocommand to use this function just after the GUI has started. Note that the GTK GUI accepts any font name, thus checking for a valid name does not work.
f fn.getfperm	The result is a String, which is the read, write, and execute permissions of the given file {fname}. If {fname} does not exist or its directory cannot be read, an empty string is returned. The result is of the form "rwxrwxrwx", where each group of "rwx" flags represent, in turn, the permissions of the owner of the file, the group the file belongs to, and other users. If a user does not have a given permission the flag for this is replaced with the string "-". Examples:
f fn.getfsize	The result is a Number, which is the size in bytes of the given file {fname}. If {fname} is a directory, 0 is returned. If the file {fname} can't be found, -1 is returned. If the size of {fname} is too big to fit in a Number then -2 is returned.
f fn.getftime	The result is a Number, which is the last modification time of the given file {fname}. The value is measured as seconds since 1st Jan 1970, and may be passed to strftime(). See also `localtime()` and `strftime()`. If the file {fname} can't be found -1 is returned.
f fn.getftype
f fn.getjumplist
f fn.getline
f fn.getloclist
f fn.getmarklist	Without the {buf} argument returns a `List` with information about all the global marks. `mark`
f fn.getmatches
f fn.getmousepos
f fn.getpid	Return a Number which is the process ID of the Vim process. On Unix and MS-Windows this is a unique number, until Vim exits.
f fn.getpos	Get the position for String {expr}. For possible values of {expr} see `line()`. For getting the cursor position see `getcurpos()`. The result is a `List` with four numbers: [bufnum, lnum, col, off] "bufnum" is zero, unless a mark like '0 or 'A is used, then it is the buffer number of the mark. "lnum" and "col" are the position in the buffer. The first column is 1. The "off" number is zero, unless 'virtualedit' is used. Then it is the offset in screen columns from the start of the character. E.g., a position within a `<Tab>` or after the last character. Note that for '< and '> Visual mode matters: when it is "V" (visual line mode) the column of '< is zero and the column of '> is a large number equal to `v:maxcol`. The column number in the returned List is the byte position within the line. To get the character position in the line, use `getcharpos()`. A very large column number equal to `v:maxcol` can be returned, in which case it means "after the end of the line". If {expr} is invalid, returns a list with all zeros. This can be used to save and restore the position of a mark:
f fn.getqflist
f fn.getreg
f fn.getreginfo
f fn.getregtype	The result is a String, which is type of register {regname}. The value will be one of: "v" for `characterwise` text "V" for `linewise` text `"<CTRL-V>{width}"` for `blockwise-visual` text "" for an empty or unknown register `<CTRL-V>` is one character with value 0x16. The {regname} argument is a string. If {regname} is "", the unnamed register '"' is used. If {regname} is not specified, `v:register` is used. In `Vim9-script` {regname} must be one character.
f fn.gettabinfo	If {tabnr} is not specified, then information about all the tab pages is returned as a `List`. Each List item is a `Dictionary`. Otherwise, {tabnr} specifies the tab page number and information about that one is returned. If the tab page does not exist an empty List is returned.
f fn.gettabvar	Get the value of a tab-local variable {varname} in tab page {tabnr}. `t:var` Tabs are numbered starting with one. The {varname} argument is a string. When {varname} is empty a dictionary with all tab-local variables is returned. Note that the name without "t:" must be used. When the tab or variable doesn't exist {def} or an empty string is returned, there is no error message.
f fn.gettabwinvar
f fn.gettagstack
f fn.getwininfo
f fn.getwinpos	The result is a `List` with two numbers, the result of `getwinposx()` and `getwinposy()` combined: [x-pos, y-pos] {timeout} can be used to specify how long to wait in msec for a response from the terminal. When omitted 100 msec is used. Use a longer time for a remote terminal. When using a value less than 10 and no response is received within that time, a previously reported position is returned, if available. This can be used to poll for the position and do some work in the meantime:
f fn.getwinposx	The result is a Number, which is the X coordinate in pixels of the left hand side of the GUI Vim window. Also works for an xterm (uses a timeout of 100 msec). The result will be -1 if the information is not available. The value can be used with `:winpos`.
f fn.getwinposy	The result is a Number, which is the Y coordinate in pixels of the top of the GUI Vim window. Also works for an xterm (uses a timeout of 100 msec). The result will be -1 if the information is not available. The value can be used with `:winpos`.
f fn.getwinvar	Like `gettabwinvar()` for the current tabpage. Examples:
f fn.glob
f fn.glob2regpat	Convert a file pattern, as used by glob(), into a search pattern. The result can be used to match with a string that is a file name. E.g.
f fn.globpath
f fn.has	Returns 1 if {feature} is supported, 0 otherwise. The {feature} argument is a feature name like "nvim-0.2.1" or "win32", see below. See also `exists()`.
f fn.has_key	The result is a Number, which is TRUE if `Dictionary` {dict} has an entry with key {key}. FALSE otherwise. The {key} argument is a string. In `Vim9` script a number is also accepted (and converted to a string) but no other types. In legacy script the usual automatic conversion to string is done.
f fn.haslocaldir
f fn.hasmapto
f fn.histadd
f fn.histdel
f fn.histget	The result is a String, the entry with Number {index} from {history}. See `hist-names` for the possible values of {history}, and `:history-indexing` for {index}. If there is no such entry, an empty String is returned. When {index} is omitted, the most recent item from the history is used.
f fn.histnr	The result is the Number of the current entry in {history}. See `hist-names` for the possible values of {history}. If an error occurred, -1 is returned.
f fn.hlexists	The result is a Number, which is TRUE if a highlight group called {name} exists. This is when the group has been defined in some way. Not necessarily when highlighting has been defined for it, it may also have been used for a syntax item.
f fn.hlID	The result is a Number, which is the ID of the highlight group with name {name}. When the highlight group doesn't exist, zero is returned. This can be used to retrieve information about the highlight group. For example, to get the background color of the "Comment" group:
f fn.hostname	The result is a String, which is the name of the machine on which Vim is currently running. Machine names greater than 256 characters long are truncated.
f fn.iconv
f fn.indent	The result is a Number, which is indent of line {lnum} in the current buffer. The indent is counted in spaces, the value of 'tabstop' is relevant. {lnum} is used just like in `getline()`. When {lnum} is invalid -1 is returned. In `Vim9` script an error is given.
f fn.index
f fn.input	The result is a String, which is whatever the user typed on the command-line. The {prompt} argument is either a prompt string, or a blank string (for no prompt). A '\n' can be used in the prompt to start a new line. The highlighting set with `:echohl` is used for the prompt. The input is entered just like a command-line, with the same editing commands and mappings. There is a separate history for lines typed for input(). Example:
f fn.inputlist	{textlist} must be a `List` of strings. This `List` is displayed, one string per line. The user will be prompted to enter a number, which is returned. The user can also select an item by clicking on it with the mouse, if the mouse is enabled in the command line ('mouse' is "a" or includes "c"). For the first string 0 is returned. When clicking above the first item a negative number is returned. When clicking on the prompt one more than the length of {textlist} is returned. Make sure {textlist} has less than 'lines' entries, otherwise it won't work. It's a good idea to put the entry number at the start of the string. And put a prompt in the first item. Example:
f fn.inputrestore	Restore typeahead that was saved with a previous `inputsave()`. Should be called the same number of times inputsave() is called. Calling it more often is harmless though. Returns TRUE when there is nothing to restore, FALSE otherwise.
f fn.inputsave	Preserve typeahead (also from mappings) and clear it, so that a following prompt gets input from the user. Should be followed by a matching inputrestore() after the prompt. Can be used several times, in which case there must be just as many inputrestore() calls. Returns TRUE when out of memory, FALSE otherwise.
f fn.inputsecret	This function acts much like the `input()` function with but two exceptions: a) the user's response will be displayed as a sequence of asterisks ("*") thereby keeping the entry secret, and b) the user's response will not be recorded on the input `history` stack. The result is a String, which is whatever the user actually typed on the command-line in response to the issued prompt. NOTE: Command-line completion is not supported.
f fn.insert
f fn.interrupt	Interrupt script execution. It works more or less like the user typing CTRL-C, most commands won't execute and control returns to the user. This is useful to abort execution from lower down, e.g. in an autocommand. Example:
f fn.invert	Bitwise invert. The argument is converted to a number. A List, Dict or Float argument causes an error. Example:
f fn.isdirectory	The result is a Number, which is `TRUE` when a directory with the name {directory} exists. If {directory} doesn't exist, or isn't a directory, the result is `FALSE`. {directory} is any expression, which is used as a String.
f fn.isinf	Return 1 if {expr} is a positive infinity, or -1 a negative infinity, otherwise 0.
f fn.islocked	The result is a Number, which is `TRUE` when {expr} is the name of a locked variable. The string argument {expr} must be the name of a variable, `List` item or `Dictionary` entry, not the variable itself! Example:
f fn.isnan	Return `TRUE` if {expr} is a float with value NaN.
f fn.isPosition	Return true if the value is Position.
f fn.isScreenPos	Return true if the value is ScreenPos.
f fn.isValidBuiltinCompletion	Check if the `value` is valid BuiltinCompletion
f fn.items	Return a `List` with all the key-value pairs of {dict}. Each `List` item is a list with two items: the key of a {dict} entry and the value of this entry. The `List` is in arbitrary order. Also see `keys()` and `values()`. Example:
f fn.join	Join the items in {list} together into one String. When {sep} is specified it is put in between the items. If {sep} is omitted a single space is used. Note that {sep} is not added at the end. You might want to add it there too:
f fn.json_decode
f fn.json_encode
f fn.keys	Return a `List` with all the keys of {dict}. The `List` is in arbitrary order. Also see `items()` and `values()`.
f fn.keytrans	Turn the internal byte representation of keys into a form that can be used for `:map`. E.g.
f fn.len	The result is a Number, which is the length of the argument. When {expr} is a String or a Number the length in bytes is used, as with `strlen()`. When {expr} is a `List` the number of items in the `List` is returned. When {expr} is a `Blob` the number of bytes is returned. When {expr} is a `Dictionary` the number of entries in the `Dictionary` is returned. Otherwise an error is given and returns zero.
f fn.libcall
f fn.libcallnr	Just like `libcall()`, but used for a function that returns an int instead of a string. only in Win32 on some Unix versions, when the `+libcall` feature is present Examples:
f fn.line	The result is a Number, which is the line number of the file position given with {expr}. The {expr} argument is a string. The accepted positions are: . the cursor position $ the last line in the current buffer 'x position of mark x (if the mark is not set, 0 is returned) w0 first line visible in current window (one if the display isn't updated, e.g. in silent Ex mode) w$ last line visible in current window (this is one less than "w0" if no lines are visible) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from `'<` in that it's updated right away. Note that a mark in another file can be used. The line number then applies to another buffer. To get the column number use `col()`. To get both use `getpos()`. With the optional {winid} argument the values are obtained for that window instead of the current window. Returns 0 for invalid values of {expr} and {winid}. Examples:
f fn.line2byte	Return the byte count from the start of the buffer for line {lnum}. This includes the end-of-line character, depending on the 'fileformat' option for the current buffer. The first line returns 1. 'encoding' matters, 'fileencoding' is ignored. This can also be used to get the byte count for the line just below the last line:
f fn.lispindent	Get the amount of indent for line {lnum} according the lisp indenting rules, as with 'lisp'. The indent is counted in spaces, the value of 'tabstop' is relevant. {lnum} is used just like in `getline()`. When {lnum} is invalid -1 is returned. In `Vim9` script an error is given.
f fn.list2str	Convert each number in {list} to a character string can concatenate them all. Examples:
f fn.localtime	Return the current time, measured as seconds since 1st Jan 1970. See also `strftime()`, `strptime()` and `getftime()`.
f fn.log	Return the natural logarithm (base e) of {expr} as a `Float`. {expr} must evaluate to a `Float` or a `Number` in the range (0, inf]. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.log10	Return the logarithm of Float {expr} to base 10 as a `Float`. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.map
f fn.maparg
f fn.mapcheck
f fn.mapset
f fn.match
f fn.matchadd
f fn.matchaddpos
f fn.matcharg	Selects the {nr} match item, as set with a `:match`, `:2match` or `:3match` command. Return a `List` with two elements: The name of the highlight group used The pattern used. When {nr} is not 1, 2 or 3 returns an empty `List`. When there is no match item set returns ['', '']. This is useful to save and restore a `:match`. Highlighting matches using the `:match` commands are limited to three matches. `matchadd()` does not have this limitation.
f fn.matchdelete	Deletes a match with ID {id} previously defined by `matchadd()` or one of the `:match` commands. Returns 0 if successful, otherwise -1. See example for `matchadd()`. All matches can be deleted in one operation by `clearmatches()`. If {win} is specified, use the window with this number or window ID instead of the current window.
f fn.matchend
f fn.matchfuzzy
f fn.matchfuzzypos
f fn.matchlist
f fn.matchstr
f fn.matchstrpos
f fn.max	Return the maximum value of all items in {expr}. Example:
f fn.menu_info
f fn.min	Return the minimum value of all items in {expr}. Example:
f fn.mkdir
f fn.mode	Return a string that indicates the current mode. If [expr] is supplied and it evaluates to a non-zero Number or a non-empty String (`non-zero-arg`), then the full mode is returned, otherwise only the first letter is returned. Also see `state()`.
f fn.nextnonblank	Return the line number of the first line at or below {lnum} that is not blank. Example:
f fn.nr2char
f fn.or	Bitwise OR on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Also see `and()` and `xor()`. Example:
f fn.pathshorten	Shorten directory names in the path {path} and return the result. The tail, the file name, is kept as-is. The other components in the path are reduced to {len} letters in length. If {len} is omitted or smaller than 1 then 1 is used (single letters). Leading `'~'` and '.' characters are kept. Examples:
f fn.perleval	Evaluate Perl expression {expr} in scalar context and return its result converted to Vim data structures. If value can't be converted, it is returned as a string Perl representation. Note: If you want an array or hash, {expr} must return a reference to it. Example:
f fn.pow	Return the power of {x} to the exponent {y} as a `Float`. {x} and {y} must evaluate to a `Float` or a `Number`. Returns 0.0 if {x} or {y} is not a `Float` or a `Number`. Examples:
f fn.prevnonblank	Return the line number of the first line at or above {lnum} that is not blank. Example:
f fn.printf
f fn.prompt_getprompt	Returns the effective prompt text for buffer {buf}. {buf} can be a buffer name or number. See `prompt-buffer`.
f fn.prompt_setcallback
f fn.prompt_setinterrupt	Set a callback for buffer {buf} to {expr}. When {expr} is an empty string the callback is removed. This has only effect if {buf} has 'buftype' set to "prompt".
f fn.prompt_setprompt	Set prompt for buffer {buf} to {text}. You most likely want {text} to end in a space. The result is only visible if {buf} has 'buftype' set to "prompt". Example:
f fn.pum_getpos	If the popup menu (see `ins-completion-menu`) is not visible, returns an empty `Dictionary`, otherwise, returns a `Dictionary` with the following keys: height nr of items visible width screen cells row top screen row (0 first row) col leftmost screen column (0 first col) size total nr of items scrollbar `TRUE` if scrollbar is visible
f fn.pumvisible	Returns non-zero when the popup menu is visible, zero otherwise. See `ins-completion-menu`. This can be used to avoid some things that would remove the popup menu.
f fn.py3eval	Evaluate Python expression {expr} and return its result converted to Vim data structures. Numbers and strings are returned as they are (strings are copied though, Unicode strings are additionally converted to 'encoding'). Lists are represented as Vim `List` type. Dictionaries are represented as Vim `Dictionary` type with keys converted to strings. Note that in a `:def` function local variables are not visible to {expr}.
f fn.pyeval	Evaluate Python expression {expr} and return its result converted to Vim data structures. Numbers and strings are returned as they are (strings are copied though). Lists are represented as Vim `List` type. Dictionaries are represented as Vim `Dictionary` type, non-string keys result in error. Note that in a `:def` function local variables are not visible to {expr}.
f fn.pyxeval	Evaluate Python expression {expr} and return its result converted to Vim data structures. Uses Python 2 or 3, see `python_x` and 'pyxversion'. See also: `pyeval()`, `py3eval()`
f fn.rand	Return a pseudo-random Number generated with an xoshiro128 algorithm using seed {expr}. The returned number is 32 bits, also on 64 bits systems, for consistency. {expr} can be initialized by `srand()` and will be updated by rand(). If {expr} is omitted, an internal seed value is used and updated. Returns -1 if {expr}** is invalid.
f fn.range
f fn.readdir
f fn.readfile
f fn.reduce
f fn.reg_executing	Returns the single letter name of the register being executed. Returns an empty string when no register is being executed. See `@`.
f fn.reg_recording	Returns the single letter name of the register being recorded. Returns an empty string when not recording. See `q`.
f fn.reltime
f fn.reltimefloat	Return a Float that represents the time value of {time}. Example:
f fn.reltimestr	Return a String that represents the time value of {time}. This is the number of seconds, a dot and the number of microseconds. Example:
f fn.remove
f fn.rename	Rename the file by the name {from} to the name {to}. This should also work to move files across file systems. The result is a Number, which is 0 if the file was renamed successfully, and non-zero when the renaming failed. NOTE: If {to} exists it is overwritten without warning. This function is not available in the `sandbox`.
f fn.repeat	Repeat {expr} {count} times and return the concatenated result. Example:
f fn.resolve
f fn.reverse	Reverse the order of items in {object} in-place. {object} can be a `List` or a `Blob`. Returns {object}. Returns zero if {object} is not a List or a Blob. If you want an object to remain unmodified make a copy first:
f fn.round	Round off {expr} to the nearest integral value and return it as a `Float`. If {expr} lies halfway between two integral values, then use the larger one (away from zero). {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.rubyeval	Evaluate Ruby expression {expr} and return its result converted to Vim data structures. Numbers, floats and strings are returned as they are (strings are copied though). Arrays are represented as Vim `List` type. Hashes are represented as Vim `Dictionary` type. Other objects are represented as strings resulted from their "Object#to_s" method. Note that in a `:def` function local variables are not visible to {expr}.
f fn.screenattr	Like `screenchar()`, but return the attribute. This is a rather arbitrary number that can only be used to compare to the attribute at other positions. Returns -1 when row or col is out of range.
f fn.screenchar	The result is a Number, which is the character at position [row, col] on the screen. This works for every possible screen position, also status lines, window separators and the command line. The top left position is row one, column one The character excludes composing characters. For double-byte encodings it may only be the first byte. This is mainly to be used for testing. Returns -1 when row or col is out of range.
f fn.screenchars	The result is a `List` of Numbers. The first number is the same as what `screenchar()` returns. Further numbers are composing characters on top of the base character. This is mainly to be used for testing. Returns an empty List when row or col is out of range.
f fn.screencol	The result is a Number, which is the current screen column of the cursor. The leftmost column has number 1. This function is mainly used for testing.
f fn.screenpos	The result is a Dict with the screen position of the text character in window {winid} at buffer line {lnum} and column {col}. {col} is a one-based byte index. The Dict has these members: row screen row col first screen column endcol last screen column curscol cursor screen column If the specified position is not visible, all values are zero. The "endcol" value differs from "col" when the character occupies more than one screen cell. E.g. for a Tab "col" can be 1 and "endcol" can be 8. The "curscol" value is where the cursor would be placed. For a Tab it would be the same as "endcol", while for a double width character it would be the same as "col". The `conceal` feature is ignored here, the column numbers are as if 'conceallevel' is zero. You can set the cursor to the right position and use `screencol()` to get the value with `conceal` taken into account. If the position is in a closed fold the screen position of the first character is returned, {col} is not used. Returns an empty Dict if {winid} is invalid.
f fn.screenrow	The result is a Number, which is the current screen row of the cursor. The top line has number one. This function is mainly used for testing. Alternatively you can use `winline()`.
f fn.screenstring	The result is a String that contains the base character and any composing characters at position [row, col] on the screen. This is like `screenchars()` but returning a String with the characters. This is mainly to be used for testing. Returns an empty String when row or col is out of range.
f fn.search
f fn.searchcount
f fn.searchdecl
f fn.searchpair
f fn.searchpairpos
f fn.searchpos
f fn.serverlist	Return a list of available server names, one per line. When there are no servers or the information is not available an empty string is returned. See also `clientserver`. only available when compiled with the `+clientserver` feature Example:
f fn.setbufline	Set line {lnum} to {text} in buffer {buf}. This works like `setline()` for the specified buffer.
f fn.setbufvar	Set option or local variable {varname} in buffer {buf} to {val}. This also works for a global or local window option, but it doesn't work for a global or local window variable. For a local window option the global value is unchanged. For the use of {buf}, see `bufname()` above. The {varname} argument is a string. Note that the variable name without "b:" must be used. Examples:
f fn.setcellwidths
f fn.setcharpos	Same as `setpos()` but uses the specified column number as the character index instead of the byte index in the line.
f fn.setcharsearch
f fn.setcmdline	Set the command line to {str} and set the cursor position to {pos}. If {pos} is omitted, the cursor is positioned after the text. Returns 0 when successful, 1 when not editing the command line.
f fn.setcmdpos	Set the cursor position in the command line to byte position {pos}. The first position is 1. Use `getcmdpos()` to obtain the current position. Only works while editing the command line, thus you must use `c_CTRL-\_e`, `c_CTRL-R_=` or `c_CTRL-R_CTRL-R` with '='. For `c_CTRL-\_e` and `c_CTRL-R_CTRL-R` with '=' the position is set after the command line is set to the expression. For `c_CTRL-R_=` it is set after evaluating the expression but before inserting the resulting text. When the number is too big the cursor is put at the end of the line. A number smaller than one has undefined results. Returns 0 when successful, 1 when not editing the command line.
f fn.setcursorcharpos	Same as `cursor()` but uses the specified column number as the character index instead of the byte index in the line.
f fn.setenv	Set environment variable {name} to {val}. Example:
f fn.setfperm
f fn.setline	Set line {lnum} of the current buffer to {text}. To insert lines use `append()`. To set lines in another buffer use `setbufline()`. Any text properties in {lnum} are cleared.
f fn.setloclist
f fn.setmatches	Restores a list of matches saved by `getmatches()` for the current window. Returns 0 if successful, otherwise -1. All current matches are cleared before the list is restored. See example for `getmatches()`. If {win} is specified, use the window with this number or window ID instead of the current window.
f fn.setpos	Set the position for String {expr}. Possible values: . the cursor 'x mark x
f fn.setqflist
f fn.setreg
f fn.settabvar	Set tab-local variable {varname} to {val} in tab page {tabnr}. `t:var` The {varname} argument is a string. Note that autocommands are blocked, side effects may not be triggered, e.g. when setting 'filetype'. Note that the variable name without "t:" must be used. Tabs are numbered starting with one. This function is not available in the `sandbox`.
f fn.settabwinvar
f fn.settagstack
f fn.setwinvar	Like `settabwinvar()` for the current tab page. Examples:
f fn.sha256	Returns a String with 64 hex characters, which is the SHA256 checksum of {string}.
f fn.shellescape
f fn.shiftwidth	Returns the effective value of 'shiftwidth'. This is the 'shiftwidth' value unless it is zero, in which case it is the 'tabstop' value. This function was introduced with patch 7.3.694 in 2012, everybody should have it by now (however it did not allow for the optional {col} argument until 8.1.542).
f fn.simplify
f fn.sin	Return the sine of {expr}, measured in radians, as a `Float`. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.sinh	Return the hyperbolic sine of {expr} as a `Float` in the range [-inf, inf]. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.sort
f fn.soundfold	Return the sound-folded equivalent of {word}. Uses the first language in 'spelllang' for the current window that supports soundfolding. 'spell' must be set. When no sound folding is possible the {word} is returned unmodified. This can be used for making spelling suggestions. Note that the method can be quite slow.
f fn.spellbadword
f fn.spellsuggest
f fn.split
f fn.sqrt	Return the non-negative square root of Float {expr} as a `Float`. {expr} must evaluate to a `Float` or a `Number`. When {expr} is negative the result is NaN (Not a Number). Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.srand	Initialize seed used by `rand()`: If {expr} is not given, seed values are initialized by reading from /dev/urandom, if possible, or using time(NULL) a.k.a. epoch time otherwise; this only has second accuracy. If {expr} is given it must be a Number. It is used to initialize the seed values. This is useful for testing or when a predictable sequence is intended.
f fn.str2float
f fn.str2list	Return a list containing the number values which represent each character in String {string}. Examples:
f fn.str2nr
f fn.strcharpart
f fn.strchars
f fn.strdisplaywidth
f fn.strftime
f fn.strgetchar	Get a Number corresponding to the character at {index} in {str}. This uses a zero-based character index, not a byte index. Composing characters are considered separate characters here. Use `nr2char()` to convert the Number to a String. Returns -1 if {index} is invalid. Also see `strcharpart()` and `strchars()`.
f fn.stridx
f fn.string
f fn.strlen	The result is a Number, which is the length of the String {string} in bytes. If the argument is a Number it is first converted to a String. For other types an error is given and zero is returned. If you want to count the number of multibyte characters use `strchars()`. Also see `len()`, `strdisplaywidth()` and `strwidth()`.
f fn.strpart
f fn.strptime
f fn.strridx
f fn.strtrans	The result is a String, which is {string} with all unprintable characters translated into printable characters `'isprint'`. Like they are shown in a window. Example:
f fn.strwidth	The result is a Number, which is the number of display cells String {string} occupies. A Tab character is counted as one cell, alternatively use `strdisplaywidth()`. When {string} contains characters with East Asian Width Class Ambiguous, this function's return value depends on 'ambiwidth'. Returns zero on error. Also see `strlen()`, `strdisplaywidth()` and `strchars()`.
f fn.submatch
f fn.substitute
f fn.swapinfo
f fn.swapname	The result is the swap file path of the buffer {expr}. For the use of {buf}, see `bufname()` above. If buffer {buf} is the current buffer, the result is equal to `:swapname` (unless there is no swap file). If buffer {buf} has no swap file, returns an empty string.
f fn.synconcealed
f fn.synID
f fn.synIDattr
f fn.synIDtrans	The result is a Number, which is the translated syntax ID of {synID}. This is the syntax group ID of what is being used to highlight the character. Highlight links given with ":highlight link" are followed.
f fn.synstack
f fn.system
f fn.systemlist	Same as `system()`, but returns a `List` with lines (parts of output separated by NL) with NULs transformed into NLs. Output is the same as `readfile()` will output with {binary} argument set to "b", except that there is no extra empty item when the result ends in a NL. Note that on MS-Windows you may get trailing CR characters.
f fn.tabpagebuflist	The result is a `List`, where each item is the number of the buffer associated with each window in the current tab page. {arg} specifies the number of the tab page to be used. When omitted the current tab page is used. When {arg} is invalid the number zero is returned. To get a list of all buffers in all tabs use this:
f fn.tabpagenr	The result is a Number, which is the number of the current tab page. The first tab page has number 1.
f fn.tabpagewinnr	Like `winnr()` but for tab page {tabarg}. {tabarg} specifies the number of tab page to be used. {arg} is used like with `winnr()`: When omitted the current window number is returned. This is the window which will be used when going to this tab page. When "$" the number of windows is returned. When "#" the previous window nr is returned. Useful examples:
f fn.tagfiles	Returns a `List` with the file names used to search for tags for the current buffer. This is the 'tags' option expanded.
f fn.taglist
f fn.tan	Return the tangent of {expr}, measured in radians, as a `Float` in the range [-inf, inf]. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.tanh	Return the hyperbolic tangent of {expr} as a `Float` in the range [-1, 1]. {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.tempname	The result is a String, which is the name of a file that doesn't exist. It can be used for a temporary file. The name is different for at least 26 consecutive calls. Example:
f fn.timer_info
f fn.timer_pause	Pause or unpause a timer. A paused timer does not invoke its callback when its time expires. Unpausing a timer may cause the callback to be invoked almost immediately if enough time has passed.
f fn.timer_start
f fn.timer_stop	Stop a timer. The timer callback will no longer be invoked. {timer} is an ID returned by timer_start(), thus it must be a Number. If {timer} does not exist there is no error.
f fn.timer_stopall	Stop all timers. The timer callbacks will no longer be invoked. Useful if a timer is misbehaving. If there are no timers there is no error.
f fn.tolower	The result is a copy of the String given, with all uppercase characters turned into lowercase (just like applying `gu` to the string). Returns an empty string on error.
f fn.toupper	The result is a copy of the String given, with all lowercase characters turned into uppercase (just like applying `gU` to the string). Returns an empty string on error.
f fn.tr
f fn.trim
f fn.trunc	Return the largest integral value with magnitude less than or equal to {expr} as a `Float` (truncate towards zero). {expr} must evaluate to a `Float` or a `Number`. Returns 0.0 if {expr} is not a `Float` or a `Number`. Examples:
f fn.type
f fn.undofile	Return the name of the undo file that would be used for a file with name {name} when writing. This uses the 'undodir' option, finding directories that exist. It does not check if the undo file exists. {name} is always expanded to the full path, since that is what is used internally. If {name} is empty undofile() returns an empty string, since a buffer without a file name will not write an undo file. Useful in combination with `:wundo` and `:rundo`. When compiled without the `+persistent_undo` option this always returns an empty string.
f fn.undotree
f fn.uniq	Remove second and succeeding copies of repeated adjacent {list} items in-place. Returns {list}. If you want a list to remain unmodified make a copy first:
f fn.values	Return a `List` with all the values of {dict}. The `List` is in arbitrary order. Also see `items()` and `keys()`. Returns zero if {dict} is not a `Dict`.
f fn.virtcol	The result is a Number, which is the screen column of the file position given with {expr}. That is, the last screen position occupied by the character at that position, when the screen would be of unlimited width. When there is a `<Tab>` at the position, the returned Number will be the column at the end of the `<Tab>`. For example, for a `<Tab>` in column 1, with 'ts' set to 8, it returns 8. `conceal` is ignored. For the byte position use `col()`.
f fn.virtcol2col
f fn.visualmode	The result is a String, which describes the last Visual mode used in the current buffer. Initially it returns an empty string, but once Visual mode has been used, it returns "v", "V", or `"<CTRL-V>"` (a single CTRL-V character) for character-wise, line-wise, or block-wise Visual mode respectively. Example:
f fn.wildmenumode	Returns `TRUE` when the wildmenu is active and `FALSE` otherwise. See 'wildmenu' and 'wildmode'. This can be used in mappings to handle the 'wildcharm' option gracefully. (Makes only sense with `mapmode-c` mappings).
f fn.win_execute
f fn.win_findbuf	Returns a `List` with `window-ID`s for windows that contain buffer {bufnr}. When there is none the list is empty.
f fn.win_getid	Get the `window-ID` for the specified window. When {win} is missing use the current window. With {win} this is the window number. The top window has number 1. Without {tab} use the current tab, otherwise the tab with number {tab}. The first tab has number one. Return zero if the window cannot be found.
f fn.win_gettype
f fn.win_gotoid	Go to window with ID {expr}. This may also change the current tabpage. Return TRUE if successful, FALSE if the window cannot be found.
f fn.win_id2tabwin	Return a list with the tab number and window number of window with ID {expr}: [tabnr, winnr]. Return [0, 0] if the window cannot be found.
f fn.win_id2win	Return the window number of window with ID {expr}. Return 0 if the window cannot be found in the current tabpage.
f fn.win_move_separator
f fn.win_move_statusline	Move window {nr}'s status line (i.e., the bottom border) by {offset} rows, as if being dragged by the mouse. {nr} can be a window number or `window-ID`. A positive {offset} moves down and a negative {offset} moves up. Moving a window's status line will change the height of the window and the height of other windows adjacent to the status line. The magnitude of movement may be smaller than specified (e.g., as a consequence of maintaining 'winminheight'). Returns TRUE if the window can be found and FALSE otherwise. Only works for the current tab page.
f fn.win_screenpos	Return the screen position of window {nr} as a list with two numbers: [row, col]. The first window always has position [1, 1], unless there is a tabline, then it is [2, 1]. {nr} can be the window number or the `window-ID`. Use zero for the current window. Returns [0, 0] if the window cannot be found in the current tabpage.
f fn.win_splitmove
f fn.winbufnr	The result is a Number, which is the number of the buffer associated with window {nr}. {nr} can be the window number or the `window-ID`. When {nr} is zero, the number of the buffer in the current window is returned. When window {nr} doesn't exist, -1 is returned. Example:
f fn.wincol	The result is a Number, which is the virtual column of the cursor in the window. This is counting screen cells from the left side of the window. The leftmost column is one.
f fn.windowsversion	The result is a String. For MS-Windows it indicates the OS version. E.g, Windows 10 is "10.0", Windows 8 is "6.2", Windows XP is "5.1". For non-MS-Windows systems the result is an empty string.
f fn.winheight	The result is a Number, which is the height of window {nr}. {nr} can be the window number or the `window-ID`. When {nr} is zero, the height of the current window is returned. When window {nr} doesn't exist, -1 is returned. An existing window always has a height of zero or more. This excludes any window toolbar line. Examples:
f fn.winlayout
f fn.winline	The result is a Number, which is the screen line of the cursor in the window. This is counting screen lines from the top of the window. The first line is one. If the cursor was moved the view on the file will be updated first, this may cause a scroll.
f fn.winnr
f fn.winrestcmd	Returns a sequence of `:resize` commands that should restore the current window sizes. Only works properly when no windows are opened or closed and the current window and tab page is unchanged. Example:
f fn.winrestview	Uses the `Dictionary` returned by `winsaveview()` to restore the view of the current window. Note: The {dict} does not have to contain all values, that are returned by `winsaveview()`. If values are missing, those settings won't be restored. So you can use:
f fn.winsaveview
f fn.winwidth	The result is a Number, which is the width of window {nr}. {nr} can be the window number or the `window-ID`. When {nr} is zero, the width of the current window is returned. When window {nr} doesn't exist, -1 is returned. An existing window always has a width of zero or more. Examples:
f fn.wordcount
f fn.writefile
f fn.xor	Bitwise XOR on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Also see `and()` and `or()`. Example:

Interfaces

I fn.BufInfo	Type of `getbufinfo()` result.
I fn.ChangeListLocation	Type of `getchangelist()` result.
I fn.GetBufInfoDictArg	Only the buffers matching the specified criteria are returned.
I fn.MarkInformation	Type of `getmarklist()` result.
I fn.PlacedSign	Type of `getbufinfo()` result.

Type Aliases

T fn.BufExistsArg	If the {buf} argument is a number, buffer numbers are used. Number zero is the alternate buffer for the current window.
T fn.BufLnumArg	For {lnum} and {end} "$" can be used for the last line of the buffer. Otherwise a number must be used.
T fn.BufNameArg	If {buf} is omitted the current buffer is used. If {buf} is a Number, that buffer number's name is given. Number zero is the alternate buffer for the current window. If {buf} is a String, it is used as a `file-pattern` to match with the buffer names. This is always done like 'magic' is set and 'cpoptions' is empty. When there is more than one match an empty string is returned. "" or "%" can be used for the current buffer, "#" for the alternate buffer. A full match is preferred, otherwise a match at the start, end or middle of the buffer name is accepted. If you only want a full match then put "^" at the start and "$" at the end of the pattern.
T fn.BuiltinCompletion	Builtin completion
T fn.ChangeList	Type of `getchangelist()` result.
T fn.GetreginfoResult
T fn.MarkPosition	Type of `getmarklist()` result.
T fn.Position	Type of `getpos()` or `setpos()` result.
T fn.ScreenPos	Type of `screenpos()` result.