VIM: usr_41

## USR_41

    *usr_41.txt*	For Vim version 8.2.  Last change: 2022 Feb 11

    		     VIM USER MANUAL - by Bram Moolenaar

    			      Write a Vim script

    The Vim script language is used for the startup vimrc file, syntax files, and
    many other things.  This chapter explains the items that can be used in a Vim
    script.  There are a lot of them, thus this is a long chapter.

    |41.1|	Introduction
    |41.2|	Variables
    |41.3|	Expressions
    |41.4|	Conditionals
    |41.5|	Executing an expression
    |41.6|	Using functions
    |41.7|	Defining a function
    |41.8|	Lists and Dictionaries
    |41.9|	Exceptions
    |41.10|	Various remarks
    |41.11|	Writing a plugin
    |41.12|	Writing a filetype plugin
    |41.13|	Writing a compiler plugin
    |41.14|	Writing a plugin that loads quickly
    |41.15|	Writing library scripts
    |41.16|	Distributing Vim scripts

         Next chapter: |usr_42|  Add new menus
     Previous chapter: |usr_40|  Make new commands
    Table of contents: |usr_toc|

    *41.1*	Introduction				*vim-script-intro* *script*

    Your first experience with Vim scripts is the vimrc file.  Vim reads it when
    it starts up and executes the commands.  You can set options to values you
    prefer.  And you can use any colon command in it (commands that start with a
    ":"; these are sometimes referred to as Ex commands or command-line commands).

    Syntax files are also Vim scripts.  As are files that set options for a
    specific file type.  A complicated macro can be defined by a separate Vim
    script file.  You can think of other uses yourself.

    	If you are familiar with Python, you can find a comparison between
    	Python and Vim script here, with pointers to other documents:
    	   https://gist.github.com/yegappan/16d964a37ead0979b05e655aa036cad0
    	And if you are familiar with JavaScript:
    	   https://w0rp.com/blog/post/vim-script-for-the-javascripter/

    Vim script comes in two flavors: legacy and |Vim9|.  Since this help file is
    for new users, we'll teach you the newer and more convenient |Vim9| syntax.

    To try out Vim script the best way is to edit a script file and source it.
    Basically:
    	:edit test.vim
    	[insert the script lines you want]
    	:w
    	:source %

    Let's start with a simple example:

    	vim9script
    	var i = 1
    	while i < 5
    	  echo "count is" i
    	  i += 1
    	endwhile

    The output of the example code is:

    	count is 1
    	count is 2
    	count is 3
    	count is 4

    In the first line the `vim9script` command makes clear this is a new, |Vim9|
    script file.  That matters for how the rest of the file is used.

    The `var i = 1` command declares the "i" variable and initializes it.  The
    generic form is:

    	var {name} = {expression}

    In this case the variable name is "i" and the expression is a simple value,
    the number one.

    The `while` command starts a loop.  The generic form is:

    	while {condition}
    	  {statements}
    	endwhile

    The statements until the matching `endwhile` are executed for as long as the
    condition is true.  The condition used here is the expression "i < 5".  This
    is true when the variable i is smaller than five.
    	Note:
    	If you happen to write a while loop that keeps on running, you can
    	interrupt it by pressing CTRL-C (CTRL-Break on MS-Windows).

    The `echo` command prints its arguments.  In this case the string "count is"
    and the value of the variable i.  Since i is one, this will print:

    	count is 1

    Then there is the `i += 1` command.  This does the same thing as "i = i + 1",
    it adds one to the variable i and assigns the new value to the same variable.

    The example was given to explain the commands, but would you really want to
    make such a loop, it can be written much more compact:

    	for i in range(1, 4)
    	  echo "count is" i
    	endfor

    We won't explain how `for` and `range()` work until later.  Follow the links
    if you are impatient.

    FOUR KINDS OF NUMBERS

    Numbers can be decimal, hexadecimal, octal or binary.

    A hexadecimal number starts with "0x" or "0X".  For example "0x1f" is decimal
    31.

    An octal number starts with "0o", "0O".  "0o17" is decimal 15.

    A binary number starts with "0b" or "0B".  For example "0b101" is decimal 5.

    A decimal number is just digits.  Careful: In legacy script don't put a zero
    before a decimal number, it will be interpreted as an octal number!

    The `echo` command evaluates its argument and always prints decimal numbers.
    Example:

    	echo 0x7f 0o36
    	127 30

    A number is made negative with a minus sign.  This also works for hexadecimal,
    octal and binary numbers:

    	echo -0x7f
    	-127

    A minus sign is also used for subtraction.  This can sometimes lead to
    confusion.  If we put a minus sign before both numbers we get an error:

    	echo -0x7f -0o36
    	E1004: White space required before and after '-' at "-0o36"

    Note: if you are not using a |Vim9| script to try out these commands but type
    them directly, they will be executed as legacy script.  Then the echo command
    sees the second minus sign as subtraction.  To get the error, prefix the
    command with `vim9cmd`:

    	vim9cmd echo -0x7f -0o36
    	E1004: White space required before and after '-' at "-0o36"

    White space in an expression is often required to make sure it is easy to read
    and avoid errors.  Such as thinking that the "-0o36" above makes the number
    negative, while it is actually seen as a subtraction.

    To actually have the minus sign be used for negation, you can put the second
    expression in parenthesis:

    	echo -0x7f (-0o36)

    *41.2*	Variables

    A variable name consists of ASCII letters, digits and the underscore.  It
    cannot start with a digit.  Valid variable names are:

    	counter
    	_aap3
    	very_long_variable_name_with_underscores
    	FuncLength
    	LENGTH

    Invalid names are "foo+bar" and "6var".

    Some variables are global.  To see a list of currently defined global
    variables type this command:

    	:let

    You can use global variables everywhere.  However, it is easy to use the same
    name in two unrelated scripts.  Therefore variables declared in a script are
    local to that script.  For example, if you have this in "script1.vim":

    	vim9script
    	var counter = 5
    	echo counter
    	5

    And you try to use the variable in "script2.vim":

    	vim9script
    	echo counter
    	E121: Undefined variable: counter

    Using a script-local variable means you can be sure that it is only changed in
    that script and not elsewhere.

    If you do want to share variables between scripts, use the "g:" prefix and
    assign the value directly, do not use `var`.  Thus in "script1.vim":

    	vim9script
    	g:counter = 5
    	echo g:counter
    	5

    And then in "script2.vim":

    	vim9script
    	echo g:counter
    	5

    More about script-local variables here: |script-variable|.

    There are more kinds of variables, see |internal-variables|.  The most often
    used ones are:

    	b:name		variable local to a buffer
    	w:name		variable local to a window
    	g:name		global variable (also in a function)
    	v:name		variable predefined by Vim

    DELETING VARIABLES

    Variables take up memory and show up in the output of the `let` command.  To
    delete a global variable use the `unlet` command.  Example:

    	unlet g:counter

    This deletes the global variable "g:counter" to free up the memory it uses.
    If you are not sure if the variable exists, and don't want an error message
    when it doesn't, append !:

    	unlet! g:counter

    You cannot `unlet` script-local variables in |Vim9| script.  You can in legacy
    script.

    When a script finishes, the local variables declared there will not be
    deleted.  Functions defined in the script can use them.  Example:

    	vim9script
    	var counter = 0
    	def g:GetCount(): number
    	  s:counter += 1
    	  return s:counter
    	enddef

    Every time you call the function it will return the next count:
    	:echo g:GetCount()
    	1

    	:echo g:GetCount()
    	2

    If you are worried a script-local variable is consuming too much
    memory, set it to an empty value after you no longer need it.

    Note: below we'll leave out the `vim9script` line, so we can concentrate on
    the relevant commands, but you'll still need to put it at the top of your
    script file.

    STRING VARIABLES AND CONSTANTS

    So far only numbers were used for the variable value.  Strings can be used as
    well.  Numbers and strings are the basic types of variables that Vim supports.
    Example:

    	var name = "Peter"
    	echo name
    	Peter

    Every variable has a type.  Very often, as in this example, the type is
    defined by assigning a value.  This is called type inference.  If you do not
    want to give the variable a value yet, you need to specify the type:

    	var name: string
    	var age: number
    	...
    	name = "Peter"
    	age = 42

    If you make a mistake and try to assign the wrong type of value you'll get an
    error:

    	age = "Peter"
    	E1012: Type mismatch; expected number but got string

    More about types in |41.8|.

    To assign a string value to a variable, you need to use a string constant.
    There are two types of these.  First the string in double quotes, as we used
    already.  If you want to include a double quote inside the string, put a
    backslash in front of it:

    	var name = "he is \"Peter\""
    	echo name
    	he is "Peter"

    To avoid the need for a backslash, you can use a string in single quotes:

    	var name = 'he is "Peter"'
    	echo name
    	he is "Peter"

    Inside a single-quote string all the characters are as they are.  Only the
    single quote itself is special: you need to use two to get one.  A backslash
    is taken literally, thus you can't use it to change the meaning of the
    character after it:

    	var name = 'P\e''ter'''
    	echo name
    	P\e'ter'

    In double-quote strings it is possible to use special characters.  Here are a
    few useful ones:

    	\t		<Tab>
    	\n		<NL>, line break
    	\r		<CR>, <Enter>
    	\e		<Esc>
    	\b		<BS>, backspace
    	\"		"
    	\\		\, backslash
    	\<Esc>		<Esc>
    	\<C-W>		CTRL-W

    The last two are just examples.  The  "\<name>" form can be used to include
    the special key "name".

    See |expr-quote| for the full list of special items in a string.

    *41.3*	Expressions

    Vim has a fairly standard way to handle expressions.  You can read the
    definition here: |expression-syntax|.  Here we will show the most common
    items.

    The numbers, strings and variables mentioned above are expressions by
    themselves.  Thus everywhere an expression is expected, you can use a number,
    string or variable.  Other basic items in an expression are:

    	$NAME		environment variable
    	&name		option
    	@r		register

    Examples:

    	echo "The value of 'tabstop' is" &ts
    	echo "Your home directory is" $HOME
    	if @a == 'text'

    The &name form can also be used to set an option value, do something and
    restore the old value.  Example:

    	var save_ic = &ic
    	set noic
    	s/The Start/The Beginning/
    	&ic = save_ic

    This makes sure the "The Start" pattern is used with the 'ignorecase' option
    off.  Still, it keeps the value that the user had set.  (Another way to do
    this would be to add "\C" to the pattern, see |/\C|.)

    MATHEMATICS

    It becomes more interesting if we combine these basic items.  Let's start with
    mathematics on numbers:

    	a + b		add
    	a - b		subtract
    	a * b		multiply
    	a / b		divide
    	a % b		modulo

    The usual precedence is used.  Example:

    	echo 10 + 5 * 2
    	20

    Grouping is done with parentheses.  No surprises here.  Example:

    	echo (10 + 5) * 2
    	30

    Strings can be concatenated with ".." (see |expr6|).  Example:

    	echo "foo" .. "bar"
    	foobar

    When the "echo" command gets multiple arguments, it separates them with a
    space.  In the example the argument is a single expression, thus no space is
    inserted.

    Borrowed from the C language is the conditional expression:

    	a ? b : c

    If "a" evaluates to true "b" is used, otherwise "c" is used.  Example:

    	var nr = 4
    	echo nr > 5 ? "nr is big" : "nr is small"
    	nr is small

    The three parts of the constructs are always evaluated first, thus you could
    see it works as:

    	(a) ? (b) : (c)

    *41.4*	Conditionals

    The `if` commands executes the following statements, until the matching
    `endif`, only when a condition is met.  The generic form is:

    	if {condition}
    	   {statements}
    	endif

    Only when the expression {condition} evaluates to true or one will the
    {statements} be executed.  If they are not executed they must still be valid
    commands.  If they contain garbage, Vim won't be able to find the matching
    `endif`.

    You can also use `else`.  The generic form for this is:

    	if {condition}
    	   {statements}
    	else
    	   {statements}
    	endif

    The second {statements} block is only executed if the first one isn't.

    Finally, there is `elseif`

    	if {condition}
    	   {statements}
    	elseif {condition}
    	   {statements}
    	endif

    This works just like using `else` and then `if`, but without the need for an
    extra `endif`.

    A useful example for your vimrc file is checking the 'term' option and doing
    something depending upon its value:

    	if &term == "xterm"
    	  # Do stuff for xterm
    	elseif &term == "vt100"
    	  # Do stuff for a vt100 terminal
    	else
    	  # Do something for other terminals
    	endif

    This uses "#" to start a comment, more about that later.

    LOGIC OPERATIONS

    We already used some of them in the examples.  These are the most often used
    ones:

    	a == b		equal to
    	a != b		not equal to
    	a >  b		greater than
    	a >= b		greater than or equal to
    	a <  b		less than
    	a <= b		less than or equal to

    The result is true if the condition is met and false otherwise.  An example:

    	if v:version >= 700
    	  echo "congratulations"
    	else
    	  echo "you are using an old version, upgrade!"
    	endif

    Here "v:version" is a variable defined by Vim, which has the value of the Vim
    version.  600 is for version 6.0, version 6.1 has the value 601.  This is
    very useful to write a script that works with multiple versions of Vim.
    |v:version|

    The logic operators work both for numbers and strings.  When comparing two
    strings, the mathematical difference is used.  This compares byte values,
    which may not be right for some languages.

    If you try to compare a string with a number you will get an error.

    For strings there are two more useful items:

    	str =~ pat		matches with
    	str !~ pat		does not match with

    The left item "str" is used as a string.  The right item "pat" is used as a
    pattern, like what's used for searching.  Example:

    	if str =~ " "
    	  echo "str contains a space"
    	endif
    	if str !~ '\.$'
    	  echo "str does not end in a full stop"
    	endif

    Notice the use of a single-quote string for the pattern.  This is useful,
    because backslashes would need to be doubled in a double-quote string and
    patterns tend to contain many backslashes.

    The match is not anchored, if you want to match the whole string start with
    "^" and end with "$".

    The 'ignorecase' option is not used when comparing strings.  When you do want
    to ignore case append "?".  Thus "==?" compares two strings to be equal while
    ignoring case.  For the full table see |expr-==|.

    MORE LOOPING

    The `while` command was already mentioned.  Two more statements can be used in
    between the `while` and the `endwhile`:

    	continue		Jump back to the start of the while loop; the
    				loop continues.
    	break			Jump forward to the `endwhile`; the loop is
    				discontinued.

    Example:

    	var counter = 1
    	while counter < 40
    	  if skip_number(counter)
    	    continue
    	  endif
    	  if last_number(counter)
    	    break
    	  endif
    	  sleep 50m
    	  ++counter
    	endwhile

    The `sleep` command makes Vim take a nap.  The "50m" specifies fifty
    milliseconds.  Another example is `sleep 4`, which sleeps for four seconds.

    Even more looping can be done with the `for` command, see below in |41.8|.

    *41.5*	Executing an expression

    So far the commands in the script were executed by Vim directly.  The
    `execute` command allows executing the result of an expression.  This is a
    very powerful way to build commands and execute them.

    An example is to jump to a tag, which is contained in a variable:

    	execute "tag " .. tag_name

    The ".." is used to concatenate the string "tag " with the value of variable
    "tag_name".  Suppose "tag_name" has the value "get_cmd", then the command that
    will be executed is:

    	tag get_cmd

    The `execute` command can only execute Ex commands.  The `normal` command
    executes Normal mode commands.  However, its argument is not an expression but
    the literal command characters.  Example:

    	normal gg=G

    This jumps to the first line with "gg" and formats all lines with the "="
    operator and the "G" movement.

    To make `normal` work with an expression, combine `execute` with it.
    Example:

    	execute "normal " .. count .. "j"

    This will move the cursor "count" lines down.

    Make sure that the argument for `normal` is a complete command.  Otherwise
    Vim will run into the end of the argument and abort the command.  For example,
    if you start the delete operator, you must give the movement command also.
    This works:

    	normal d$

    This does nothing:

    	normal d

    If you start Insert mode and do not end it with Esc, it will end anyway.  This
    works to insert "new text":

    	execute "normal inew text"

    If you want to do something after inserting text you do need to end Insert
    mode:

    	execute "normal inew text\<Esc>b"

    This inserts "new text" and puts the cursor on the first letter of "text".
    Notice the use of the special key "\<Esc>".  This avoids having to enter a
    real <Esc> character in your script.  That is where `execute` with a
    double-quote string comes in handy.

    If you don't want to execute a string but evaluate it to get its expression
    value, you can use the eval() function:

    	var optname = "path"
    	var optvalue = eval('&' .. optname)

    A "&" character is prepended to "path", thus the argument to eval() is
    "&path".  The result will then be the value of the 'path' option.

    *41.6*	Using functions

    Vim defines many functions and provides a large amount of functionality that
    way.  A few examples will be given in this section.  You can find the whole
    list below: |function-list|.

    A function is called with the `call` command.  The parameters are passed in
    between parentheses separated by commas.  Example:

    	call search("Date: ", "W")

    This calls the search() function, with arguments "Date: " and "W".  The
    search() function uses its first argument as a search pattern and the second
    one as flags.  The "W" flag means the search doesn't wrap around the end of
    the file.

    Using `call` is optional in |Vim9| script, this works the same way:

    	search("Date: ", "W")

    A function can be called in an expression.  Example:

    	var line = getline(".")
    	var repl = substitute(line, '\a', "*", "g")
    	setline(".", repl)

    The getline() function obtains a line from the current buffer.  Its argument
    is a specification of the line number.  In this case "." is used, which means
    the line where the cursor is.

    The substitute() function does something similar to the `substitute` command.
    The first argument is the string on which to perform the substitution.  The
    second argument is the pattern, the third the replacement string.  Finally,
    the last arguments are the flags.

    The setline() function sets the line, specified by the first argument, to a
    new string, the second argument.  In this example the line under the cursor is
    replaced with the result of the substitute().  Thus the effect of the three
    statements is equal to:

    	:substitute/\a/*/g

    Using the functions becomes more interesting when you do more work before and
    after the substitute() call.

    FUNCTIONS						*function-list*

    There are many functions.  We will mention them here, grouped by what they are
    used for.  You can find an alphabetical list here: |builtin-function-list|.
    Use CTRL-] on the function name to jump to detailed help on it.

    String manipulation:					*string-functions*
    	nr2char()		get a character by its number value
    	list2str()		get a character string from a list of numbers
    	char2nr()		get number value of a character
    	str2list()		get list of numbers from a string
    	str2nr()		convert a string to a Number
    	str2float()		convert a string to a Float
    	printf()		format a string according to % items
    	escape()		escape characters in a string with a '\'
    	shellescape()		escape a string for use with a shell command
    	fnameescape()		escape a file name for use with a Vim command
    	tr()			translate characters from one set to another
    	strtrans()		translate a string to make it printable
    	tolower()		turn a string to lowercase
    	toupper()		turn a string to uppercase
    	charclass()		class of a character
    	match()			position where a pattern matches in a string
    	matchend()		position where a pattern match ends in a string
    	matchfuzzy()		fuzzy matches a string in a list of strings
    	matchfuzzypos()		fuzzy matches a string in a list of strings
    	matchstr()		match of a pattern in a string
    	matchstrpos()		match and positions of a pattern in a string
    	matchlist()		like matchstr() and also return submatches
    	stridx()		first index of a short string in a long string
    	strridx()		last index of a short string in a long string
    	strlen()		length of a string in bytes
    	strcharlen()		length of a string in characters
    	strchars()		number of characters in a string
    	strwidth()		size of string when displayed
    	strdisplaywidth()	size of string when displayed, deals with tabs
    	setcellwidths()		set character cell width overrides
    	substitute()		substitute a pattern match with a string
    	submatch()		get a specific match in ":s" and substitute()
    	strpart()		get part of a string using byte index
    	strcharpart()		get part of a string using char index
    	slice()			take a slice of a string, using char index in
    				Vim9 script
    	strgetchar()		get character from a string using char index
    	expand()		expand special keywords
    	expandcmd()		expand a command like done for `:edit`
    	iconv()			convert text from one encoding to another
    	byteidx()		byte index of a character in a string
    	byteidxcomp()		like byteidx() but count composing characters
    	charidx()		character index of a byte in a string
    	repeat()		repeat a string multiple times
    	eval()			evaluate a string expression
    	execute()		execute an Ex command and get the output
    	win_execute()		like execute() but in a specified window
    	trim()			trim characters from a string
    	gettext()		lookup message translation

    List manipulation:					*list-functions*
    	get()			get an item without error for wrong index
    	len()			number of items in a List
    	empty()			check if List is empty
    	insert()		insert an item somewhere in a List
    	add()			append an item to a List
    	extend()		append a List to a List
    	extendnew()		make a new List and append items
    	remove()		remove one or more items from a List
    	copy()			make a shallow copy of a List
    	deepcopy()		make a full copy of a List
    	filter()		remove selected items from a List
    	map()			change each List item
    	mapnew()		make a new List with changed items
    	reduce()		reduce a List to a value
    	slice()			take a slice of a List
    	sort()			sort a List
    	reverse()		reverse the order of a List
    	uniq()			remove copies of repeated adjacent items
    	split()			split a String into a List
    	join()			join List items into a String
    	range()			return a List with a sequence of numbers
    	string()		String representation of a List
    	call()			call a function with List as arguments
    	index()			index of a value in a List
    	max()			maximum value in a List
    	min()			minimum value in a List
    	count()			count number of times a value appears in a List
    	repeat()		repeat a List multiple times
    	flatten()		flatten a List
    	flattennew()		flatten a copy of a List

    Dictionary manipulation:				*dict-functions*
    	get()			get an entry without an error for a wrong key
    	len()			number of entries in a Dictionary
    	has_key()		check whether a key appears in a Dictionary
    	empty()			check if Dictionary is empty
    	remove()		remove an entry from a Dictionary
    	extend()		add entries from one Dictionary to another
    	extendnew()		make a new Dictionary and append items
    	filter()		remove selected entries from a Dictionary
    	map()			change each Dictionary entry
    	mapnew()		make a new Dictionary with changed items
    	keys()			get List of Dictionary keys
    	values()		get List of Dictionary values
    	items()			get List of Dictionary key-value pairs
    	copy()			make a shallow copy of a Dictionary
    	deepcopy()		make a full copy of a Dictionary
    	string()		String representation of a Dictionary
    	max()			maximum value in a Dictionary
    	min()			minimum value in a Dictionary
    	count()			count number of times a value appears

    Floating point computation:				*float-functions*
    	float2nr()		convert Float to Number
    	abs()			absolute value (also works for Number)
    	round()			round off
    	ceil()			round up
    	floor()			round down
    	trunc()			remove value after decimal point
    	fmod()			remainder of division
    	exp()			exponential
    	log()			natural logarithm (logarithm to base e)
    	log10()			logarithm to base 10
    	pow()			value of x to the exponent y
    	sqrt()			square root
    	sin()			sine
    	cos()			cosine
    	tan()			tangent
    	asin()			arc sine
    	acos()			arc cosine
    	atan()			arc tangent
    	atan2()			arc tangent
    	sinh()			hyperbolic sine
    	cosh()			hyperbolic cosine
    	tanh()			hyperbolic tangent
    	isinf()			check for infinity
    	isnan()			check for not a number

    Blob manipulation:					*blob-functions*
    	blob2list()		get a list of numbers from a blob
    	list2blob()		get a blob from a list of numbers

    Other computation:					*bitwise-function*
    	and()			bitwise AND
    	invert()		bitwise invert
    	or()			bitwise OR
    	xor()			bitwise XOR
    	sha256()		SHA-256 hash
    	rand()			get a pseudo-random number
    	srand()			initialize seed used by rand()

    Variables:						*var-functions*
    	type()			type of a variable as a number
    	typename()		type of a variable as text
    	islocked()		check if a variable is locked
    	funcref()		get a Funcref for a function reference
    	function()		get a Funcref for a function name
    	getbufvar()		get a variable value from a specific buffer
    	setbufvar()		set a variable in a specific buffer
    	getwinvar()		get a variable from specific window
    	gettabvar()		get a variable from specific tab page
    	gettabwinvar()		get a variable from specific window & tab page
    	setwinvar()		set a variable in a specific window
    	settabvar()		set a variable in a specific tab page
    	settabwinvar()		set a variable in a specific window & tab page
    	garbagecollect()	possibly free memory

    Cursor and mark position:		*cursor-functions* *mark-functions*
    	col()			column number of the cursor or a mark
    	virtcol()		screen column of the cursor or a mark
    	line()			line number of the cursor or mark
    	wincol()		window column number of the cursor
    	winline()		window line number of the cursor
    	cursor()		position the cursor at a line/column
    	screencol()		get screen column of the cursor
    	screenrow()		get screen row of the cursor
    	screenpos()		screen row and col of a text character
    	getcurpos()		get position of the cursor
    	getpos()		get position of cursor, mark, etc.
    	setpos()		set position of cursor, mark, etc.
    	getmarklist()		list of global/local marks
    	byte2line()		get line number at a specific byte count
    	line2byte()		byte count at a specific line
    	diff_filler()		get the number of filler lines above a line
    	screenattr()		get attribute at a screen line/row
    	screenchar()		get character code at a screen line/row
    	screenchars()		get character codes at a screen line/row
    	screenstring()		get string of characters at a screen line/row
    	charcol()		character number of the cursor or a mark
    	getcharpos()		get character position of cursor, mark, etc.
    	setcharpos()		set character position of cursor, mark, etc.
    	getcursorcharpos()	get character position of the cursor
    	setcursorcharpos()	set character position of the cursor

    Working with text in the current buffer:		*text-functions*
    	getline()		get a line or list of lines from the buffer
    	setline()		replace a line in the buffer
    	append()		append line or list of lines in the buffer
    	indent()		indent of a specific line
    	cindent()		indent according to C indenting
    	lispindent()		indent according to Lisp indenting
    	nextnonblank()		find next non-blank line
    	prevnonblank()		find previous non-blank line
    	search()		find a match for a pattern
    	searchpos()		find a match for a pattern
    	searchcount()		get number of matches before/after the cursor
    	searchpair()		find the other end of a start/skip/end
    	searchpairpos()		find the other end of a start/skip/end
    	searchdecl()		search for the declaration of a name
    	getcharsearch()		return character search information
    	setcharsearch()		set character search information

    Working with text in another buffer:
    	getbufline()		get a list of lines from the specified buffer
    	setbufline()		replace a line in the specified buffer
    	appendbufline()		append a list of lines in the specified buffer
    	deletebufline()		delete lines from a specified buffer

    					*system-functions* *file-functions*
    System functions and manipulation of files:
    	glob()			expand wildcards
    	globpath()		expand wildcards in a number of directories
    	glob2regpat()		convert a glob pattern into a search pattern
    	findfile()		find a file in a list of directories
    	finddir()		find a directory in a list of directories
    	resolve()		find out where a shortcut points to
    	fnamemodify()		modify a file name
    	pathshorten()		shorten directory names in a path
    	simplify()		simplify a path without changing its meaning
    	executable()		check if an executable program exists
    	exepath()		full path of an executable program
    	filereadable()		check if a file can be read
    	filewritable()		check if a file can be written to
    	getfperm()		get the permissions of a file
    	setfperm()		set the permissions of a file
    	getftype()		get the kind of a file
    	isdirectory()		check if a directory exists
    	getfsize()		get the size of a file
    	getcwd()		get the current working directory
    	haslocaldir()		check if current window used |:lcd| or |:tcd|
    	tempname()		get the name of a temporary file
    	mkdir()			create a new directory
    	chdir()			change current working directory
    	delete()		delete a file
    	rename()		rename a file
    	system()		get the result of a shell command as a string
    	systemlist()		get the result of a shell command as a list
    	environ()		get all environment variables
    	getenv()		get one environment variable
    	setenv()		set an environment variable
    	hostname()		name of the system
    	readfile()		read a file into a List of lines
    	readblob()		read a file into a Blob
    	readdir()		get a List of file names in a directory
    	readdirex()		get a List of file information in a directory
    	writefile()		write a List of lines or Blob into a file

    Date and Time:				*date-functions* *time-functions*
    	getftime()		get last modification time of a file
    	localtime()		get current time in seconds
    	strftime()		convert time to a string
    	strptime()		convert a date/time string to time
    	reltime()		get the current or elapsed time accurately
    	reltimestr()		convert reltime() result to a string
    	reltimefloat()		convert reltime() result to a Float

    			*buffer-functions* *window-functions* *arg-functions*
    Buffers, windows and the argument list:
    	argc()			number of entries in the argument list
    	argidx()		current position in the argument list
    	arglistid()		get id of the argument list
    	argv()			get one entry from the argument list
    	bufadd()		add a file to the list of buffers
    	bufexists()		check if a buffer exists
    	buflisted()		check if a buffer exists and is listed
    	bufload()		ensure a buffer is loaded
    	bufloaded()		check if a buffer exists and is loaded
    	bufname()		get the name of a specific buffer
    	bufnr()			get the buffer number of a specific buffer
    	tabpagebuflist()	return List of buffers in a tab page
    	tabpagenr()		get the number of a tab page
    	tabpagewinnr()		like winnr() for a specified tab page
    	winnr()			get the window number for the current window
    	bufwinid()		get the window ID of a specific buffer
    	bufwinnr()		get the window number of a specific buffer
    	winbufnr()		get the buffer number of a specific window
    	listener_add()		add a callback to listen to changes
    	listener_flush()	invoke listener callbacks
    	listener_remove()	remove a listener callback
    	win_findbuf()		find windows containing a buffer
    	win_getid()		get window ID of a window
    	win_gettype()		get type of window
    	win_gotoid()		go to window with ID
    	win_id2tabwin()		get tab and window nr from window ID
    	win_id2win()		get window nr from window ID
    	win_move_separator()	move window vertical separator
    	win_move_statusline()	move window status line
    	win_splitmove()		move window to a split of another window
    	getbufinfo()		get a list with buffer information
    	gettabinfo()		get a list with tab page information
    	getwininfo()		get a list with window information
    	getchangelist()		get a list of change list entries
    	getjumplist()		get a list of jump list entries
    	swapinfo()		information about a swap file
    	swapname()		get the swap file path of a buffer

    Command line:					*command-line-functions*
    	getcmdline()		get the current command line
    	getcmdpos()		get position of the cursor in the command line
    	setcmdpos()		set position of the cursor in the command line
    	getcmdtype()		return the current command-line type
    	getcmdwintype()		return the current command-line window type
    	getcompletion()		list of command-line completion matches
    	fullcommand()		get full command name

    Quickfix and location lists:			*quickfix-functions*
    	getqflist()		list of quickfix errors
    	setqflist()		modify a quickfix list
    	getloclist()		list of location list items
    	setloclist()		modify a location list

    Insert mode completion:				*completion-functions*
    	complete()		set found matches
    	complete_add()		add to found matches
    	complete_check()	check if completion should be aborted
    	complete_info()		get current completion information
    	pumvisible()		check if the popup menu is displayed
    	pum_getpos()		position and size of popup menu if visible

    Folding:					*folding-functions*
    	foldclosed()		check for a closed fold at a specific line
    	foldclosedend()		like foldclosed() but return the last line
    	foldlevel()		check for the fold level at a specific line
    	foldtext()		generate the line displayed for a closed fold
    	foldtextresult()	get the text displayed for a closed fold

    Syntax and highlighting:	  *syntax-functions* *highlighting-functions*
    	clearmatches()		clear all matches defined by |matchadd()| and
    				the |:match| commands
    	getmatches()		get all matches defined by |matchadd()| and
    				the |:match| commands
    	hlexists()		check if a highlight group exists
    	hlget()			get highlight group attributes
    	hlset()			set highlight group attributes
    	hlID()			get ID of a highlight group
    	synID()			get syntax ID at a specific position
    	synIDattr()		get a specific attribute of a syntax ID
    	synIDtrans()		get translated syntax ID
    	synstack()		get list of syntax IDs at a specific position
    	synconcealed()		get info about concealing
    	diff_hlID()		get highlight ID for diff mode at a position
    	matchadd()		define a pattern to highlight (a "match")
    	matchaddpos()		define a list of positions to highlight
    	matcharg()		get info about |:match| arguments
    	matchdelete()		delete a match defined by |matchadd()| or a
    				|:match| command
    	setmatches()		restore a list of matches saved by
    				|getmatches()|

    Spelling:					*spell-functions*
    	spellbadword()		locate badly spelled word at or after cursor
    	spellsuggest()		return suggested spelling corrections
    	soundfold()		return the sound-a-like equivalent of a word

    History:					*history-functions*
    	histadd()		add an item to a history
    	histdel()		delete an item from a history
    	histget()		get an item from a history
    	histnr()		get highest index of a history list

    Interactive:					*interactive-functions*
    	browse()		put up a file requester
    	browsedir()		put up a directory requester
    	confirm()		let the user make a choice
    	getchar()		get a character from the user
    	getcharstr()		get a character from the user as a string
    	getcharmod()		get modifiers for the last typed character
    	getmousepos()		get last known mouse position
    	echoraw()		output characters as-is
    	feedkeys()		put characters in the typeahead queue
    	input()			get a line from the user
    	inputlist()		let the user pick an entry from a list
    	inputsecret()		get a line from the user without showing it
    	inputdialog()		get a line from the user in a dialog
    	inputsave()		save and clear typeahead
    	inputrestore()		restore typeahead

    GUI:						*gui-functions*
    	getfontname()		get name of current font being used
    	getwinpos()		position of the Vim window
    	getwinposx()		X position of the Vim window
    	getwinposy()		Y position of the Vim window
    	balloon_show()		set the balloon content
    	balloon_split()		split a message for a balloon
    	balloon_gettext()	get the text in the balloon

    Vim server:					*server-functions*
    	serverlist()		return the list of server names
    	remote_startserver()	run a server
    	remote_send()		send command characters to a Vim server
    	remote_expr()		evaluate an expression in a Vim server
    	server2client()		send a reply to a client of a Vim server
    	remote_peek()		check if there is a reply from a Vim server
    	remote_read()		read a reply from a Vim server
    	foreground()		move the Vim window to the foreground
    	remote_foreground()	move the Vim server window to the foreground

    Window size and position:			*window-size-functions*
    	winheight()		get height of a specific window
    	winwidth()		get width of a specific window
    	win_screenpos()		get screen position of a window
    	winlayout()		get layout of windows in a tab page
    	winrestcmd()		return command to restore window sizes
    	winsaveview()		get view of current window
    	winrestview()		restore saved view of current window

    Mappings and Menus:			    *mapping-functions*
    	digraph_get()		get |digraph|
    	digraph_getlist()	get all |digraph|s
    	digraph_set()		register |digraph|
    	digraph_setlist()	register multiple |digraph|s
    	hasmapto()		check if a mapping exists
    	mapcheck()		check if a matching mapping exists
    	maparg()		get rhs of a mapping
    	mapset()		restore a mapping
    	menu_info()		get information about a menu item
    	wildmenumode()		check if the wildmode is active

    Testing:				    *test-functions*
    	assert_equal()		assert that two expressions values are equal
    	assert_equalfile()	assert that two file contents are equal
    	assert_notequal()	assert that two expressions values are not equal
    	assert_inrange()	assert that an expression is inside a range
    	assert_match()		assert that a pattern matches the value
    	assert_notmatch()	assert that a pattern does not match the value
    	assert_false()		assert that an expression is false
    	assert_true()		assert that an expression is true
    	assert_exception()	assert that a command throws an exception
    	assert_beeps()		assert that a command beeps
    	assert_nobeep()		assert that a command does not cause a beep
    	assert_fails()		assert that a command fails
    	assert_report()		report a test failure
    	test_alloc_fail()	make memory allocation fail
    	test_autochdir()	enable 'autochdir' during startup
    	test_override()		test with Vim internal overrides
    	test_garbagecollect_now()   free memory right now
    	test_garbagecollect_soon()  set a flag to free memory soon
    	test_getvalue()		get value of an internal variable
    	test_gui_event()	generate a GUI event for testing
    	test_ignore_error()	ignore a specific error message
    	test_null_blob()	return a null Blob
    	test_null_channel()	return a null Channel
    	test_null_dict()	return a null Dict
    	test_null_function()	return a null Funcref
    	test_null_job()		return a null Job
    	test_null_list()	return a null List
    	test_null_partial()	return a null Partial function
    	test_null_string()	return a null String
    	test_settime()		set the time Vim uses internally
    	test_setmouse()		set the mouse position
    	test_feedinput()	add key sequence to input buffer
    	test_option_not_set()	reset flag indicating option was set
    	test_refcount()		return an expression's reference count
    	test_srand_seed()	set the seed value for srand()
    	test_unknown()		return a value with unknown type
    	test_void()		return a value with void type

    Inter-process communication:		    *channel-functions*
    	ch_canread()		check if there is something to read
    	ch_open()		open a channel
    	ch_close()		close a channel
    	ch_close_in()		close the in part of a channel
    	ch_read()		read a message from a channel
    	ch_readblob()		read a Blob from a channel
    	ch_readraw()		read a raw message from a channel
    	ch_sendexpr()		send a JSON message over a channel
    	ch_sendraw()		send a raw message over a channel
    	ch_evalexpr()		evaluate an expression over channel
    	ch_evalraw()		evaluate a raw string over channel
    	ch_status()		get status of a channel
    	ch_getbufnr()		get the buffer number of a channel
    	ch_getjob()		get the job associated with a channel
    	ch_info()		get channel information
    	ch_log()		write a message in the channel log file
    	ch_logfile()		set the channel log file
    	ch_setoptions()		set the options for a channel
    	json_encode()		encode an expression to a JSON string
    	json_decode()		decode a JSON string to Vim types
    	js_encode()		encode an expression to a JSON string
    	js_decode()		decode a JSON string to Vim types

    Jobs:						*job-functions*
    	job_start()		start a job
    	job_stop()		stop a job
    	job_status()		get the status of a job
    	job_getchannel()	get the channel used by a job
    	job_info()		get information about a job
    	job_setoptions()	set options for a job

    Signs:						*sign-functions*
    	sign_define()		define or update a sign
    	sign_getdefined()	get a list of defined signs
    	sign_getplaced()	get a list of placed signs
    	sign_jump()		jump to a sign
    	sign_place()		place a sign
    	sign_placelist()	place a list of signs
    	sign_undefine()		undefine a sign
    	sign_unplace()		unplace a sign
    	sign_unplacelist()	unplace a list of signs

    Terminal window:				*terminal-functions*
    	term_start()		open a terminal window and run a job
    	term_list()		get the list of terminal buffers
    	term_sendkeys()		send keystrokes to a terminal
    	term_wait()		wait for screen to be updated
    	term_getjob()		get the job associated with a terminal
    	term_scrape()		get row of a terminal screen
    	term_getline()		get a line of text from a terminal
    	term_getattr()		get the value of attribute {what}
    	term_getcursor()	get the cursor position of a terminal
    	term_getscrolled()	get the scroll count of a terminal
    	term_getaltscreen()	get the alternate screen flag
    	term_getsize()		get the size of a terminal
    	term_getstatus()	get the status of a terminal
    	term_gettitle()		get the title of a terminal
    	term_gettty()		get the tty name of a terminal
    	term_setansicolors()	set 16 ANSI colors, used for GUI
    	term_getansicolors()	get 16 ANSI colors, used for GUI
    	term_dumpdiff()		display difference between two screen dumps
    	term_dumpload()		load a terminal screen dump in a window
    	term_dumpwrite()	dump contents of a terminal screen to a file
    	term_setkill()		set signal to stop job in a terminal
    	term_setrestore()	set command to restore a terminal
    	term_setsize()		set the size of a terminal
    	term_setapi()		set terminal JSON API function name prefix

    Popup window:					*popup-window-functions*
    	popup_create()		create popup centered in the screen
    	popup_atcursor()	create popup just above the cursor position,
    				closes when the cursor moves away
    	popup_beval()		at the position indicated by v:beval_
    				variables, closes when the mouse moves away
    	popup_notification()	show a notification for three seconds
    	popup_dialog()		create popup centered with padding and border
    	popup_menu()		prompt for selecting an item from a list
    	popup_hide()		hide a popup temporarily
    	popup_show()		show a previously hidden popup
    	popup_move()		change the position and size of a popup
    	popup_setoptions()	override options of a popup
    	popup_settext()		replace the popup buffer contents
    	popup_close()		close one popup
    	popup_clear()		close all popups
    	popup_filter_menu()	select from a list of items
    	popup_filter_yesno()	block until 'y' or 'n' is pressed
    	popup_getoptions()	get current options for a popup
    	popup_getpos()		get actual position and size of a popup
    	popup_findinfo()	get window ID for popup info window
    	popup_findpreview()	get window ID for popup preview window
    	popup_list()		get list of all popup window IDs
    	popup_locate()		get popup window ID from its screen position

    Timers:						*timer-functions*
    	timer_start()		create a timer
    	timer_pause()		pause or unpause a timer
    	timer_stop()		stop a timer
    	timer_stopall()		stop all timers
    	timer_info()		get information about timers

    Tags:						*tag-functions*
    	taglist()		get list of matching tags
    	tagfiles()		get a list of tags files
    	gettagstack()		get the tag stack of a window
    	settagstack()		modify the tag stack of a window

    Prompt Buffer:					*promptbuffer-functions*
    	prompt_getprompt()	get the effective prompt text for a buffer
    	prompt_setcallback()	set prompt callback for a buffer
    	prompt_setinterrupt()	set interrupt callback for a buffer
    	prompt_setprompt()	set the prompt text for a buffer

    Text Properties:				*text-property-functions*
    	prop_add()		attach a property at a position
    	prop_add_list()		attach a property at multiple positions
    	prop_clear()		remove all properties from a line or lines
    	prop_find()		search for a property
    	prop_list()		return a list of all properties in a line
    	prop_remove()		remove a property from a line
    	prop_type_add()		add/define a property type
    	prop_type_change()	change properties of a type
    	prop_type_delete()	remove a text property type
    	prop_type_get()		return the properties of a type
    	prop_type_list()	return a list of all property types

    Sound:							*sound-functions*
    	sound_clear()		stop playing all sounds
    	sound_playevent()	play an event's sound
    	sound_playfile()	play a sound file
    	sound_stop()		stop playing a sound

    Various:					*various-functions*
    	mode()			get current editing mode
    	state()			get current busy state
    	visualmode()		last visual mode used
    	exists()		check if a variable, function, etc. exists
    	exists_compiled()	like exists() but check at compile time
    	has()			check if a feature is supported in Vim
    	changenr()		return number of most recent change
    	cscope_connection()	check if a cscope connection exists
    	did_filetype()		check if a FileType autocommand was used
    	eventhandler()		check if invoked by an event handler
    	getpid()		get process ID of Vim
    	getimstatus()		check if IME status is active
    	interrupt()		interrupt script execution
    	windowsversion()	get MS-Windows version
    	terminalprops()		properties of the terminal

    	libcall()		call a function in an external library
    	libcallnr()		idem, returning a number

    	undofile()		get the name of the undo file
    	undotree()		return the state of the undo tree

    	getreg()		get contents of a register
    	getreginfo()		get information about a register
    	getregtype()		get type of a register
    	setreg()		set contents and type of a register
    	reg_executing()		return the name of the register being executed
    	reg_recording()		return the name of the register being recorded

    	shiftwidth()		effective value of 'shiftwidth'

    	wordcount()		get byte/word/char count of buffer

    	luaeval()		evaluate |Lua| expression
    	mzeval()		evaluate |MzScheme| expression
    	perleval()		evaluate Perl expression (|+perl|)
    	py3eval()		evaluate Python expression (|+python3|)
    	pyeval()		evaluate Python expression (|+python|)
    	pyxeval()		evaluate |python_x| expression
    	rubyeval()		evaluate |Ruby| expression

    	debugbreak()		interrupt a program being debugged

    *41.7*	Defining a function

    Vim enables you to define your own functions.  The basic function declaration
    begins as follows:

    	def {name}({var1}, {var2}, ...): return-type
    	  {body}
    	enddef

    	Note:
    	Function names must begin with a capital letter.

    Let's define a short function to return the smaller of two numbers.  It starts
    with this line:

    	def Min(num1: number, num2: number): number

    This tells Vim that the function is named "Min", it takes two arguments that
    are numbers: "num1" and "num2" and returns a number.

    The first thing you need to do is to check to see which number is smaller:

    	if num1 < num2

    Let's assign the variable "smaller" the value of the smallest number:

    	var smaller: number
    	if num1 < num2
    	  smaller = num1
    	else
    	  smaller = num2
    	endif

    The variable "smaller" is a local variable.  Variables used inside a function
    are local unless prefixed by something like "g:", "w:", or "s:".

    	Note:
    	To access a global variable from inside a function you must prepend
    	"g:" to it.  Thus "g:today" inside a function is used for the global
    	variable "today", and "today" is another variable, local to the
    	function or the script.

    You now use the `return` statement to return the smallest number to the user.
    Finally, you end the function:

    	  return smaller
    	enddef

    The complete function definition is as follows:

    	def Min(num1: number, num2: number): number
    	  var smaller: number
    	  if num1 < num2
    	    smaller = num1
    	  else
    	    smaller = num2
    	  endif
    	  return smaller
    	enddef

    Obviously this is a verbose example.  You can make it shorter by using two
    return commands:

    	def Min(num1: number, num2: number): number
    	  if num1 < num2
    	    return num1
    	  endif
    	  return num2
    	enddef

    And if you remember the conditional expression, you need only one line:

    	def Min(num1: number, num2: number): number
    	  return num1 < num2 ? num1 : num2
    	enddef

    A user defined function is called in exactly the same way as a built-in
    function.  Only the name is different.  The Min function can be used like
    this:

    	echo Min(5, 8)

    Only now will the function be executed and the lines be parsed by Vim.
    If there are mistakes, like using an undefined variable or function, you will
    now get an error message.  When defining the function these errors are not
    detected.  To get the errors sooner you can tell Vim to compile all the
    functions in the script:

    	defcompile

    For a function that does not return anything leave out the return type:

    	def SayIt(text: string)
    	  echo text
    	enddef

    It is also possible to define a legacy function with `function` and
    `endfunction`.  These do not have types and are not compiled.  They execute
    much slower.

    USING A RANGE

    A line range can be used with a function call.  The function will be called
    once for every line in the range, with the cursor in that line.  Example:

    	def Number()
    	  echo "line " .. line(".") .. " contains: " .. getline(".")
    	enddef

    If you call this function with:

    	:10,15call Number()

    The function will be called six times, starting on line 10 and ending on line
    15.

    VARIABLE NUMBER OF ARGUMENTS

    Vim enables you to define functions that have a variable number of arguments.
    The following command, for instance, defines a function that must have 1
    argument (start) and can have up to 20 additional arguments:

    	def Show(start: string, ...items: list<string>)

    The variable "items" will be a list containing the extra arguments.  You can
    use it like any list, for example:

    	def Show(start: string, ...items: list<string>)
    	  echohl Title
    	  echo "start is " .. start
    	  echohl None
    	  for index in range(len(items))
    	    echon "  Arg " .. index .. " is " .. items[index]
    	  endfor
    	  echo
    	enddef

    You can call it like this:

    	Show('Title', 'one', 'two', 'three')
    	start is Title  Arg 0 is one  Arg 1 is two  Arg 2 is three

    This uses the `echohl` command to specify the highlighting used for the
    following `echo` command.  `echohl None` stops it again.  The `echon` command
    works like `echo`, but doesn't output a line break.

    If you call it with one argument the "items" list will be empty.
    `range(len(items))` returns a list with the indexes, what `for` loops over,
    we'll explain that further down.

    LISTING FUNCTIONS

    The `function` command lists the names and arguments of all user-defined
    functions:

    	:function
    	def <SNR>86_Show(start: string, ...items: list<string>)
    	function GetVimIndent()
    	function SetSyn(name)

    The "<SNR>" prefix means that a function is script-local.  |Vim9| functions
    wil start with "def" and include argument and return types.  Legacy functions
    are listed with "function".

    To see what a function does, use its name as an argument for `function`:

    	:function SetSyn
    	1     if &syntax == ''
    	2       let &syntax = a:name
    	3     endif
    	   endfunction

    To see the "Show" function you need to include the script prefix, since a
    "Show" function can be defined multiple times in different scripts.  To find
    the exact name you can use `function`, but the result may be a very long list.
    To only get the functions matching a pattern you can use the `filter` prefix:

    	:filter Show function
    	def <SNR>86_Show(start: string, ...items: list<string>)

    	:function <SNR>86_Show
    	1    echohl Title
    	2    echo "start is " .. start
    	etc.

    DEBUGGING

    The line number is useful for when you get an error message or when debugging.
    See |debug-scripts| about debugging mode.

    You can also set the 'verbose' option to 12 or higher to see all function
    calls.  Set it to 15 or higher to see every executed line.

    DELETING A FUNCTION

    To delete the SetSyn() function:

    	:delfunction SetSyn

    Deleting only works for global functions and functions in legacy script, not
    for functions defined in a |Vim9| script.

    You get an error when the function doesn't exist or cannot be deleted.

    FUNCTION REFERENCES

    Sometimes it can be useful to have a variable point to one function or
    another.  You can do it with function reference variable.  Often shortened to
    "funcref".  Example:

    	def Right()
    	  return 'Right!'
    	enddef
    	def Wrong()
    	  return 'Wrong!'
    	enddef

    	var Afunc = g:result == 1 ? Right : Wrong
    	Afunc()
    	Wrong!

    This assumes "g:result" is not one.

    Note that the name of a variable that holds a function reference must start
    with a capital.  Otherwise it could be confused with the name of a builtin
    function.

    More information about defining your own functions here: |user-functions|.

    *41.8*	Lists and Dictionaries

    So far we have used the basic types String and Number.  Vim also supports two
    composite types: List and Dictionary.

    A List is an ordered sequence of items.  The items can be any kind of value,
    thus you can make a List of numbers, a List of Lists and even a List of mixed
    items.  To create a List with three strings:

    	var alist = ['aap', 'mies', 'noot']

    The List items are enclosed in square brackets and separated by commas.  To
    create an empty List:

    	var alist = []

    You can add items to a List with the add() function:

    	var alist = []
    	add(alist, 'foo')
    	add(alist, 'bar')
    	echo alist
    	['foo', 'bar']

    List concatenation is done with +:

    	var alist = ['foo', 'bar']
    	alist = alist + ['and', 'more']
    	echo alist
    	['foo', 'bar', 'and', 'more']

    Or, if you want to extend a List with a function:

    	var alist = ['one']
    	extend(alist, ['two', 'three'])
    	echo alist
    	['one', 'two', 'three']

    Notice that using `add()` will have a different effect:

    	var alist = ['one']
    	add(alist, ['two', 'three'])
    	echo alist
    	['one', ['two', 'three']]

    The second argument of add() is added as an item, now you have a nested list.

    FOR LOOP

    One of the nice things you can do with a List is iterate over it:

    	var alist = ['one', 'two', 'three']
    	for n in alist
    	  echo n
    	endfor
    	one
    	two
    	three

    This will loop over each element in List "alist", assigning each value to
    variable "n".  The generic form of a for loop is:

    	for {varname} in {listexpression}
    	  {commands}
    	endfor

    To loop a certain number of times you need a List of a specific length.  The
    range() function creates one for you:

    	for a in range(3)
    	  echo a
    	endfor
    	0
    	1
    	2

    Notice that the first item of the List that range() produces is zero, thus the
    last item is one less than the length of the list.

    You can also specify the maximum value, the stride and even go backwards:

    	for a in range(8, 4, -2)
    	  echo a
    	endfor
    	8
    	6
    	4

    A more useful example, looping over lines in the buffer:

    	for line in getline(1, 20)
    	  if line =~ "Date: "
    	    echo line
    	  endif
    	endfor

    This looks into lines 1 to 20 (inclusive) and echoes any date found in there.

    DICTIONARIES

    A Dictionary stores key-value pairs.  You can quickly lookup a value if you
    know the key.  A Dictionary is created with curly braces:

    	var uk2nl = {one: 'een', two: 'twee', three: 'drie'}

    Now you can lookup words by putting the key in square brackets:

    	echo uk2nl['two']
    	twee

    If the key does not have special characters, you can use the dot notation:

    	echo uk2nl.two
    	twee

    The generic form for defining a Dictionary is:

    	{<key> : <value>, ...}

    An empty Dictionary is one without any keys:

    	{}

    The possibilities with Dictionaries are numerous.  There are various functions
    for them as well.  For example, you can obtain a list of the keys and loop
    over them:

    	for key in keys(uk2nl)
    	  echo key
    	endfor
    	three
    	one
    	two

    You will notice the keys are not ordered.  You can sort the list to get a
    specific order:

    	for key in sort(keys(uk2nl))
    	  echo key
    	endfor
    	one
    	three
    	two

    But you can never get back the order in which items are defined.  For that you
    need to use a List, it stores items in an ordered sequence.

    For further reading see |Lists| and |Dictionaries|.

    *41.9*	Exceptions

    Let's start with an example:

    	try
    	   read ~/templates/pascal.tmpl
    	catch /E484:/
    	   echo "Sorry, the Pascal template file cannot be found."
    	endtry

    The `read` command will fail if the file does not exist.  Instead of
    generating an error message, this code catches the error and gives the user a
    nice message.

    For the commands in between `try` and `endtry` errors are turned into
    exceptions.  An exception is a string.  In the case of an error the string
    contains the error message.  And every error message has a number.  In this
    case, the error we catch contains "E484:".  This number is guaranteed to stay
    the same (the text may change, e.g., it may be translated).

    Besides being able to give a nice error message, Vim will also continue
    executing commands.  Otherwise, once an uncaught error is encountered,
    execution will be aborted.

    When the `read` command causes another error, the pattern "E484:" will not
    match in it.  Thus this exception will not be caught and result in the usual
    error message.

    You might be tempted to do this:

    	try
    	   read ~/templates/pascal.tmpl
    	catch
    	   echo "Sorry, the Pascal template file cannot be found."
    	endtry

    This means all errors are caught.  But then you will not see an error that
    would indicate a completely different problem, such as "E21: Cannot make
    changes, 'modifiable' is off".

    Another useful mechanism is the `finally` command:

    	var tmp = tempname()
    	try
    	   exe ":.,$write " .. tmp
    	   exe "!filter " .. tmp
    	   :.,$delete
    	   exe ":$read " .. tmp
    	finally
    	   call delete(tmp)
    	endtry

    This filters the lines from the cursor until the end of the file through the
    "filter" command, which takes a file name argument.  No matter if the
    filtering works, something goes wrong in between `try` and `finally` or the
    user cancels the filtering by pressing CTRL-C, the `call delete(tmp)` is
    always executed.  This makes sure you don't leave the temporary file behind.

    More information about exception handling can be found in the reference
    manual: |exception-handling|.

    *41.10*	Various remarks

    Here is a summary of items that are useful to know when writing Vim scripts.

    The end-of-line character depends on the system.  For Vim scripts it is
    recommended to always use the Unix fileformat, this also works on any other
    system.  That way you can copy your Vim scripts from MS-Windows to Unix and
    they still work.  See |:source_crnl|.  To be sure it is set right, do this
    before writing the file:

    	:setlocal fileformat=unix

    WHITE SPACE

    Blank lines are allowed and ignored.

    Leading whitespace characters (blanks and TABs) are always ignored.

    Trailing whitespace is often ignored, but not always.  One command that
    includes it is `map`.

    To include a whitespace character in the value of an option, it must be
    escaped by a "\" (backslash)  as in the following example:

    	:set tags=my\ nice\ file

    The same example written as:

    	:set tags=my nice file

    will issue an error, because it is interpreted as:

    	:set tags=my
    	:set nice
    	:set file

    |Vim9| script is very picky when it comes to white space.  This was done
    intentionally to make sure scripts are easy to read and to avoid mistakes.

    COMMENTS

    In |Vim9| script the character # starts a comment.  Everything after
    and including this character until the end-of-line is considered a comment and
    is ignored, except for commands that don't consider comments, as shown in
    examples below.  A comment can start on any character position on the line,
    but not when it is part of the command, e.g. in a string.

    The character " (the double quote mark) starts a comment in legacy script.

    There is a little "catch" with comments for some commands.  Examples:

    	abbrev dev development	# shorthand
    	map <F3> o#include	# insert include
    	execute cmd		# do it
    	!ls *.c			# list C files

    The abbreviation 'dev' will be expanded to 'development  # shorthand'.  The
    mapping of <F3> will actually be the whole line after the 'o# ....' including
    the '# insert include'.  The `execute` command will give an error.  The `!`
    command will send everything after it to the shell, most likely causing an
    error.

    There can be no comment after `map`, `abbreviate`, `execute` and `!` commands
    (there are a few more commands with this restriction).  For the `map`,
    `abbreviate` and `execute` commands there is a trick:

    	abbrev dev development|# shorthand
    	map <F3> o#include|# insert include
    	execute '!ls *.c'	|# do it

    With the '|' character the command is separated from the next one.  And that
    next command is only a comment.  The last command, using `execute` is a
    general solution, it works for all commands that do not accept a comment or a
    '|' to separate the next command.

    Notice that there is no white space before the '|' in the abbreviation and
    mapping.  For these commands, any character until the end-of-line or '|' is
    included.  As a consequence of this behavior, you don't always see that
    trailing whitespace is included:

    	map <F4> o#include

    To spot these problems, you can highlight trailing spaces:
    	match Search /\s\+$/

    For Unix there is one special way to comment a line, that allows making a Vim
    script executable, and it also works in legacy script:
    	#!/usr/bin/env vim -S
    	echo "this is a Vim script"
    	quit

    PITFALLS

    An even bigger problem arises in the following example:

    	map ,ab o#include
    	unmap ,ab

    Here the unmap command will not work, because it tries to unmap ",ab ".  This
    does not exist as a mapped sequence.  An error will be issued, which is very
    hard to identify, because the ending whitespace character in `unmap ,ab ` is
    not visible.

    And this is the same as what happens when one uses a comment after an 'unmap'
    command:

    	unmap ,ab     # comment

    Here the comment part will be ignored.  However, Vim will try to unmap
    ',ab     ', which does not exist.  Rewrite it as:

    	unmap ,ab|    # comment

    RESTORING THE VIEW

    Sometimes you want to make a change and go back to where the cursor was.
    Restoring the relative position would also be nice, so that the same line
    appears at the top of the window.

    This example yanks the current line, puts it above the first line in the file
    and then restores the view:

    	map ,p ma"aYHmbgg"aP`bzt`a

    What this does:
    	ma"aYHmbgg"aP`bzt`a
    	ma			set mark a at cursor position
    	  "aY			yank current line into register a
    	     Hmb		go to top line in window and set mark b there
    		gg		go to first line in file
    		  "aP		put the yanked line above it
    		     `b		go back to top line in display
    		       zt	position the text in the window as before
    			 `a	go back to saved cursor position

    PACKAGING

    Sometimes you will want to use global variables or functions, so that they can
    be used anywhere.  A good example is a global variable that passes a
    preference to a  plugin.  To avoid other scripts using the same name, use a
    prefix that is very unlikely to be used elsewhere.  For example, if you have a
    "mytags" plugin, you could use:

    	g:mytags_location = '$HOME/project'
    	g:mytags_style = 'fast'

    To minimize interference between plugins keep as much as possible local to the
    script.  |Vim9| script helps you with that, by default functions and variables
    are script-local.

    If you split your plugin into parts, you can use `import` and `export` to
    share items between those parts.  See `:export` for the details.

    *41.11*	Writing a plugin				*write-plugin*

    You can write a Vim script in such a way that many people can use it.  This is
    called a plugin.  Vim users can drop your script in their plugin directory and
    use its features right away |add-plugin|.

    There are actually two types of plugins:

      global plugins: For all types of files.
    filetype plugins: Only for files of a specific type.

    In this section the first type is explained.  Most items are also relevant for
    writing filetype plugins.  The specifics for filetype plugins are in the next
    section |write-filetype-plugin|.

    NAME

    First of all you must choose a name for your plugin.  The features provided
    by the plugin should be clear from its name.  And it should be unlikely that
    someone else writes a plugin with the same name but which does something
    different.

    A script that corrects typing mistakes could be called "typecorrect.vim".  We
    will use it here as an example.

    For the plugin to work for everybody, it should follow a few guidelines.  This
    will be explained step-by-step.  The complete example plugin is at the end.

    BODY

    Let's start with the body of the plugin, the lines that do the actual work:

     14	iabbrev teh the
     15	iabbrev otehr other
     16	iabbrev wnat want
     17	iabbrev synchronisation
     18		\ synchronization

    The actual list should be much longer, of course.

    The line numbers have only been added to explain a few things, don't put them
    in your plugin file!

    FIRST LINE

      1	vim9script noclear

    You need to use `vimscript` as the very first command.  Best is to put it in
    the very first line.

    The script we are writing will have a `finish` command to bail out when it is
    loaded a second time.  To avoid the items defined in the script are lost the
    "noclear" argument is used.  More info about this at |vim9-reload|.

    HEADER

    You will probably add new corrections to the plugin and soon have several
    versions lying around.  And when distributing this file, people will want to
    know who wrote this wonderful plugin and where they can send remarks.
    Therefore, put a header at the top of your plugin:

      2	# Vim global plugin for correcting typing mistakes
      3	# Last Change:	2021 Dec 30
      4	# Maintainer:	Bram Moolenaar <Bram@vim.org>

    About copyright and licensing: Since plugins are very useful and it's hardly
    worth restricting their distribution, please consider making your plugin
    either public domain or use the Vim |license|.  A short note about this near
    the top of the plugin should be sufficient.  Example:

      5	# License:	This file is placed in the public domain.

    LINE CONTINUATION AND AVOIDING SIDE EFFECTS		 *use-cpo-save*

    In line 18 above, the line-continuation mechanism is used |line-continuation|.
    Users with 'compatible' set will run into trouble here, they will get an error
    message.  We can't just reset 'compatible', because that has a lot of side
    effects.  Instead, we will set the 'cpoptions' option to its Vim default
    value and restore it later.  That will allow the use of line-continuation and
    make the script work for most people.  It is done like this:

     11	var save_cpo = &cpo
     12	set cpo&vim
     ..
     42	&cpo = save_cpo

    We first store the old value of 'cpoptions' in the "save_cpo" variable.  At
    the end of the plugin this value is restored.

    Notice that "save_cpo" is a script-local variable.  A global variable could
    already be in use for something else.  Always use script-local variables for
    things that are only used in the script.

    NOT LOADING

    It is possible that a user doesn't always want to load this plugin.  Or the
    system administrator has dropped it in the system-wide plugin directory, but a
    user has his own plugin he wants to use.  Then the user must have a chance to
    disable loading this specific plugin.  These lines will make it possible:

      7	if exists("g:loaded_typecorrect")
      8	  finish
      9	endif
     10	g:loaded_typecorrect = 1

    This also avoids that when the script is loaded twice it would pointlessly
    redefine functions and cause trouble for autocommands that are added twice.

    The name is recommended to start with "g:loaded_" and then the file name of
    the plugin, literally.  The "g:" is prepended to make the variable global, so
    that other places can check whether its functionality is available.  Without
    "g:" it would be local to the script.

    Using `finish` stops Vim from reading the rest of the file, it's much quicker
    than using if-endif around the whole file, since Vim would still need to parse
    the commands to find the `endif`.

    MAPPING

    Now let's make the plugin more interesting: We will add a mapping that adds a
    correction for the word under the cursor.  We could just pick a key sequence
    for this mapping, but the user might already use it for something else.  To
    allow the user to define which keys a mapping in a plugin uses, the <Leader>
    item can be used:

     22	  map <unique> <Leader>a  <Plug>TypecorrAdd;

    The "<Plug>TypecorrAdd;" thing will do the work, more about that further on.

    The user can set the "g:mapleader" variable to the key sequence that he wants
    plugin mappings to start with.  Thus if the user has done:

    	g:mapleader = "_"

    the mapping will define "_a".  If the user didn't do this, the default value
    will be used, which is a backslash.  Then a map for "\a" will be defined.

    Note that <unique> is used, this will cause an error message if the mapping
    already happened to exist. |:map-<unique>|

    But what if the user wants to define his own key sequence?  We can allow that
    with this mechanism:

     21	if !hasmapto('<Plug>TypecorrAdd;')
     22	  map <unique> <Leader>a  <Plug>TypecorrAdd;
     23	endif

    This checks if a mapping to "<Plug>TypecorrAdd;" already exists, and only
    defines the mapping from "<Leader>a" if it doesn't.  The user then has a
    chance of putting this in his vimrc file:

    	map ,c  <Plug>TypecorrAdd;

    Then the mapped key sequence will be ",c" instead of "_a" or "\a".

    PIECES

    If a script gets longer, you often want to break up the work in pieces.  You
    can use functions or mappings for this.  But you don't want these functions
    and mappings to interfere with the ones from other scripts.  For example, you
    could define a function Add(), but another script could try to define the same
    function.  To avoid this, we define the function local to the script.
    Fortunately, in |Vim9| script this is the default.  In a legacy script you
    would need to prefix the name with "s:".

    We will define a function that adds a new typing correction:

     30	def Add(from: string, correct: bool)
     31	  var to = input("type the correction for " .. from .. ": ")
     32	  exe ":iabbrev " .. from .. " " .. to
     ..
     36	enddef

    Now we can call the function Add() from within this script.  If another
    script also defines Add(), it will be local to that script and can only
    be called from that script.  There can also be a global g:Add() function,
    which is again another function.

    <SID> can be used with mappings.  It generates a script ID, which identifies
    the current script.  In our typing correction plugin we use it like this:

     24	noremap <unique> <script> <Plug>TypecorrAdd;  <SID>Add
     ..
     28	noremap <SID>Add  :call <SID>Add(expand("<cword>"), true)<CR>

    Thus when a user types "\a", this sequence is invoked:

    	\a  ->  <Plug>TypecorrAdd;  ->  <SID>Add  ->  :call <SID>Add(...)

    If another script also maps <SID>Add, it will get another script ID and
    thus define another mapping.

    Note that instead of Add() we use <SID>Add() here.  That is because the
    mapping is typed by the user, thus outside of the script context.  The <SID>
    is translated to the script ID, so that Vim knows in which script to look for
    the Add() function.

    This is a bit complicated, but it's required for the plugin to work together
    with other plugins.  The basic rule is that you use <SID>Add() in mappings and
    Add() in other places (the script itself, autocommands, user commands).

    We can also add a menu entry to do the same as the mapping:

     26	noremenu <script> Plugin.Add\ Correction      <SID>Add

    The "Plugin" menu is recommended for adding menu items for plugins.  In this
    case only one item is used.  When adding more items, creating a submenu is
    recommended.  For example, "Plugin.CVS" could be used for a plugin that offers
    CVS operations "Plugin.CVS.checkin", "Plugin.CVS.checkout", etc.

    Note that in line 28 ":noremap" is used to avoid that any other mappings cause
    trouble.  Someone may have remapped ":call", for example.  In line 24 we also
    use ":noremap", but we do want "<SID>Add" to be remapped.  This is why
    "<script>" is used here.  This only allows mappings which are local to the
    script. |:map-<script>|  The same is done in line 26 for ":noremenu".
    |:menu-<script>|

    <SID> AND <Plug>					*using-<Plug>*

    Both <SID> and <Plug> are used to avoid that mappings of typed keys interfere
    with mappings that are only to be used from other mappings.  Note the
    difference between using <SID> and <Plug>:

    <Plug>	is visible outside of the script.  It is used for mappings which the
    	user might want to map a key sequence to.  <Plug> is a special code
    	that a typed key will never produce.
    	To make it very unlikely that other plugins use the same sequence of
    	characters, use this structure: <Plug> scriptname mapname
    	In our example the scriptname is "Typecorr" and the mapname is "Add".
    	We add a semicolon as the terminator.  This results in
    	"<Plug>TypecorrAdd;".  Only the first character of scriptname and
    	mapname is uppercase, so that we can see where mapname starts.

    <SID>	is the script ID, a unique identifier for a script.
    	Internally Vim translates <SID> to "<SNR>123_", where "123" can be any
    	number.  Thus a function "<SID>Add()" will have a name "<SNR>11_Add()"
    	in one script, and "<SNR>22_Add()" in another.  You can see this if
    	you use the ":function" command to get a list of functions.  The
    	translation of <SID> in mappings is exactly the same, that's how you
    	can call a script-local function from a mapping.

    USER COMMAND

    Now let's add a user command to add a correction:

     38	if !exists(":Correct")
     39	  command -nargs=1  Correct  :call Add(<q-args>, false)
     40	endif

    The user command is defined only if no command with the same name already
    exists.  Otherwise we would get an error here.  Overriding the existing user
    command with ":command!" is not a good idea, this would probably make the user
    wonder why the command he defined himself doesn't work.  |:command|
    If it did happen you can find out who to blame with:

    	verbose command Correct

    SCRIPT VARIABLES

    When a variable starts with "s:" it is a script variable.  It can only be used
    inside a script.  Outside the script it's not visible.  This avoids trouble
    with using the same variable name in different scripts.  The variables will be
    kept as long as Vim is running.  And the same variables are used when sourcing
    the same script again. |s:var|

    The nice thing about |Vim9| script is that variables are local to the script
    by default.  You can prepend "s:" if you like, but you do not need to.  And
    functions in the script can also use the script variables without a prefix.

    Script-local variables can also be used in functions, autocommands and user
    commands that are defined in the script.  Thus they are the perfect way to
    share information between parts of your plugin, without it leaking out.  In
    our example we can add a few lines to count the number of corrections:

     19	var count = 4
     ..
     30	def Add(from: string, correct: bool)
     ..
     34	  count += 1
     35	  echo "you now have " .. count .. " corrections"
     36	enddef

    "count" is declared and initialized to 4 in the script itself.  When later
    the Add() function is called, it increments "count".  It doesn't matter from
    where the function was called, since it has been defined in the script, it
    will use the local variables from this script.

    THE RESULT

    Here is the resulting complete example:

      1	vim9script noclear
      2	# Vim global plugin for correcting typing mistakes
      3	# Last Change:	2021 Dec 30
      4	# Maintainer:	Bram Moolenaar <Bram@vim.org>
      5	# License:	This file is placed in the public domain.
      6
      7	if exists("g:loaded_typecorrect")
      8	  finish
      9	endif
     10	g:loaded_typecorrect = 1
     11	var save_cpo = &cpo
     12	set cpo&vim
     13
     14	iabbrev teh the
     15	iabbrev otehr other
     16	iabbrev wnat want
     17	iabbrev synchronisation
     18		\ synchronization
     19	var count = 4
     20
     21	if !hasmapto('<Plug>TypecorrAdd;')
     22	  map <unique> <Leader>a  <Plug>TypecorrAdd;
     23	endif
     24	noremap <unique> <script> <Plug>TypecorrAdd;  <SID>Add
     25
     26	noremenu <script> Plugin.Add\ Correction      <SID>Add
     27
     28	noremap <SID>Add  :call <SID>Add(expand("<cword>"), true)<CR>
     29
     30	def Add(from: string, correct: bool)
     31	  var to = input("type the correction for " .. from .. ": ")
     32	  exe ":iabbrev " .. from .. " " .. to
     33	  if correct | exe "normal viws\<C-R>\" \b\e" | endif
     34	  count += 1
     35	  echo "you now have " .. count .. " corrections"
     36	enddef
     37
     38	if !exists(":Correct")
     39	  command -nargs=1  Correct  call Add(<q-args>, false)
     40	endif
     41
     42	&cpo = save_cpo

    Line 33 wasn't explained yet.  It applies the new correction to the word under
    the cursor.  The |:normal| command is used to use the new abbreviation.  Note
    that mappings and abbreviations are expanded here, even though the function
    was called from a mapping defined with ":noremap".

    DOCUMENTATION						*write-local-help*

    It's a good idea to also write some documentation for your plugin.  Especially
    when its behavior can be changed by the user.  See |add-local-help| for how
    they are installed.

    Here is a simple example for a plugin help file, called "typecorrect.txt":

      1	*typecorrect.txt*	Plugin for correcting typing mistakes
      2
      3	If you make typing mistakes, this plugin will have them corrected
      4	automatically.
      5
      6	There are currently only a few corrections.  Add your own if you like.
      7
      8	Mappings:
      9	<Leader>a   or   <Plug>TypecorrAdd;
     10		Add a correction for the word under the cursor.
     11
     12	Commands:
     13	:Correct {word}
     14		Add a correction for {word}.
     15
     16							*typecorrect-settings*
     17	This plugin doesn't have any settings.

    The first line is actually the only one for which the format matters.  It will
    be extracted from the help file to be put in the "LOCAL ADDITIONS:" section of
    help.txt |local-additions|.  The first "*" must be in the first column of the
    first line.  After adding your help file do ":help" and check that the entries
    line up nicely.

    You can add more tags inside ** in your help file.  But be careful not to use
    existing help tags.  You would probably use the name of your plugin in most of
    them, like "typecorrect-settings" in the example.

    Using references to other parts of the help in || is recommended.  This makes
    it easy for the user to find associated help.

    FILETYPE DETECTION					*plugin-filetype*

    If your filetype is not already detected by Vim, you should create a filetype
    detection snippet in a separate file.  It is usually in the form of an
    autocommand that sets the filetype when the file name matches a pattern.
    Example:

    	au BufNewFile,BufRead *.foo		setlocal filetype=foofoo

    Write this single-line file as "ftdetect/foofoo.vim" in the first directory
    that appears in 'runtimepath'.  For Unix that would be
    "~/.vim/ftdetect/foofoo.vim".  The convention is to use the name of the
    filetype for the script name.

    You can make more complicated checks if you like, for example to inspect the
    contents of the file to recognize the language.  Also see |new-filetype|.

    SUMMARY							*plugin-special*

    Summary of special things to use in a plugin:

    var name		Variable local to the script.

    <SID>			Script-ID, used for mappings and functions local to
    			the script.

    hasmapto()		Function to test if the user already defined a mapping
    			for functionality the script offers.

    <Leader>		Value of "mapleader", which the user defines as the
    			keys that plugin mappings start with.

    map <unique>		Give a warning if a mapping already exists.

    noremap <script>	Use only mappings local to the script, not global
    			mappings.

    exists(":Cmd")		Check if a user command already exists.

    *41.12*	Writing a filetype plugin	*write-filetype-plugin* *ftplugin*

    A filetype plugin is like a global plugin, except that it sets options and
    defines mappings for the current buffer only.  See |add-filetype-plugin| for
    how this type of plugin is used.

    First read the section on global plugins above |41.11|.  All that is said there
    also applies to filetype plugins.  There are a few extras, which are explained
    here.  The essential thing is that a filetype plugin should only have an
    effect on the current buffer.

    DISABLING

    If you are writing a filetype plugin to be used by many people, they need a
    chance to disable loading it.  Put this at the top of the plugin:

    	# Only do this when not done yet for this buffer
    	if exists("b:did_ftplugin")
    	  finish
    	endif
    	b:did_ftplugin = 1

    This also needs to be used to avoid that the same plugin is executed twice for
    the same buffer (happens when using an ":edit" command without arguments).

    Now users can disable loading the default plugin completely by making a
    filetype plugin with only these lines:

    	vim9script
    	b:did_ftplugin = 1

    This does require that the filetype plugin directory comes before $VIMRUNTIME
    in 'runtimepath'!

    If you do want to use the default plugin, but overrule one of the settings,
    you can write the different setting in a script:

    	setlocal textwidth=70

    Now write this in the "after" directory, so that it gets sourced after the
    distributed "vim.vim" ftplugin |after-directory|.  For Unix this would be
    "~/.vim/after/ftplugin/vim.vim".  Note that the default plugin will have set
    "b:did_ftplugin", but it is ignored here.

    OPTIONS

    To make sure the filetype plugin only affects the current buffer use the

    	setlocal

    command to set options.  And only set options which are local to a buffer (see
    the help for the option to check that).  When using `:setlocal` for global
    options or options local to a window, the value will change for many buffers,
    and that is not what a filetype plugin should do.

    When an option has a value that is a list of flags or items, consider using
    "+=" and "-=" to keep the existing value.  Be aware that the user may have
    changed an option value already.  First resetting to the default value and
    then changing it is often a good idea.  Example:

    	setlocal formatoptions& formatoptions+=ro

    MAPPINGS

    To make sure mappings will only work in the current buffer use the

    	map <buffer>

    command.  This needs to be combined with the two-step mapping explained above.
    An example of how to define functionality in a filetype plugin:

    	if !hasmapto('<Plug>JavaImport;')
    	  map <buffer> <unique> <LocalLeader>i <Plug>JavaImport;
    	endif
    	noremap <buffer> <unique> <Plug>JavaImport; oimport ""<Left><Esc>

    |hasmapto()| is used to check if the user has already defined a map to
    <Plug>JavaImport;.  If not, then the filetype plugin defines the default
    mapping.  This starts with |<LocalLeader>|, which allows the user to select
    the key(s) he wants filetype plugin mappings to start with.  The default is a
    backslash.
    "<unique>" is used to give an error message if the mapping already exists or
    overlaps with an existing mapping.
    |:noremap| is used to avoid that any other mappings that the user has defined
    interferes.  You might want to use ":noremap <script>" to allow remapping
    mappings defined in this script that start with <SID>.

    The user must have a chance to disable the mappings in a filetype plugin,
    without disabling everything.  Here is an example of how this is done for a
    plugin for the mail filetype:

    	# Add mappings, unless the user didn't want this.
    	if !exists("g:no_plugin_maps") && !exists("g:no_mail_maps")
    	  # Quote text by inserting "> "
    	  if !hasmapto('<Plug>MailQuote;')
    	    vmap <buffer> <LocalLeader>q <Plug>MailQuote;
    	    nmap <buffer> <LocalLeader>q <Plug>MailQuote;
    	  endif
    	  vnoremap <buffer> <Plug>MailQuote; :s/^/> /<CR>
    	  nnoremap <buffer> <Plug>MailQuote; :.,$s/^/> /<CR>
    	endif

    Two global variables are used:
    |g:no_plugin_maps|	disables mappings for all filetype plugins
    |g:no_mail_maps|	disables mappings for the "mail" filetype

    USER COMMANDS

    To add a user command for a specific file type, so that it can only be used in
    one buffer, use the "-buffer" argument to |:command|.  Example:

    	command -buffer  Make  make %:r.s

    VARIABLES

    A filetype plugin will be sourced for each buffer of the type it's for.  Local
    script variables will be shared between all invocations.  Use local buffer
    variables |b:var| if you want a variable specifically for one buffer.

    FUNCTIONS

    When defining a function, this only needs to be done once.  But the filetype
    plugin will be sourced every time a file with this filetype will be opened.
    This construct makes sure the function is only defined once:

    	if !exists("*Func")
    	  def Func(arg)
    	    ...
    	  enddef
    	endif

    UNDO						*undo_indent* *undo_ftplugin*

    When the user does ":setfiletype xyz" the effect of the previous filetype
    should be undone.  Set the b:undo_ftplugin variable to the commands that will
    undo the settings in your filetype plugin.  Example:

    	let b:undo_ftplugin = "setlocal fo< com< tw< commentstring<"
    		\ .. "| unlet b:match_ignorecase b:match_words b:match_skip"

    Using ":setlocal" with "<" after the option name resets the option to its
    global value.  That is mostly the best way to reset the option value.

    This does require removing the "C" flag from 'cpoptions' to allow line
    continuation, as mentioned above |use-cpo-save|.

    For undoing the effect of an indent script, the b:undo_indent variable should
    be set accordingly.

    Both these variables use legacy script syntax, not |Vim9| syntax.

    FILE NAME

    The filetype must be included in the file name |ftplugin-name|.  Use one of
    these three forms:

    	.../ftplugin/stuff.vim
    	.../ftplugin/stuff_foo.vim
    	.../ftplugin/stuff/bar.vim

    "stuff" is the filetype, "foo" and "bar" are arbitrary names.

    SUMMARY							*ftplugin-special*

    Summary of special things to use in a filetype plugin:

    <LocalLeader>		Value of "maplocalleader", which the user defines as
    			the keys that filetype plugin mappings start with.

    map <buffer>		Define a mapping local to the buffer.

    noremap <script>	Only remap mappings defined in this script that start
    			with <SID>.

    setlocal		Set an option for the current buffer only.

    command -buffer	Define a user command local to the buffer.

    exists("*s:Func")	Check if a function was already defined.

    Also see |plugin-special|, the special things used for all plugins.

    *41.13*	Writing a compiler plugin		*write-compiler-plugin*

    A compiler plugin sets options for use with a specific compiler.  The user can
    load it with the |:compiler| command.  The main use is to set the
    'errorformat' and 'makeprg' options.

    Easiest is to have a look at examples.  This command will edit all the default
    compiler plugins:

    	next $VIMRUNTIME/compiler/*.vim

    Type `:next` to go to the next plugin file.

    There are two special items about these files.  First is a mechanism to allow
    a user to overrule or add to the default file.  The default files start with:

    	if exists("g:current_compiler")
    	  finish
    	endif
    	g:current_compiler = "mine"

    When you write a compiler file and put it in your personal runtime directory
    (e.g., ~/.vim/compiler for Unix), you set the "current_compiler" variable to
    make the default file skip the settings.
    							*:CompilerSet*
    The second mechanism is to use ":set" for ":compiler!" and ":setlocal" for
    ":compiler".  Vim defines the ":CompilerSet" user command for this.  However,
    older Vim versions don't, thus your plugin should define it then.  This is an
    example:

      if exists(":CompilerSet") != 2
        command -nargs=* CompilerSet setlocal <args>
      endif
      CompilerSet errorformat&		" use the default 'errorformat'
      CompilerSet makeprg=nmake

    When you write a compiler plugin for the Vim distribution or for a system-wide
    runtime directory, use the mechanism mentioned above.  When
    "current_compiler" was already set by a user plugin nothing will be done.

    When you write a compiler plugin to overrule settings from a default plugin,
    don't check "current_compiler".  This plugin is supposed to be loaded
    last, thus it should be in a directory at the end of 'runtimepath'.  For Unix
    that could be ~/.vim/after/compiler.

    *41.14*	Writing a plugin that loads quickly	*write-plugin-quickload*

    A plugin may grow and become quite long.  The startup delay may become
    noticeable, while you hardly ever use the plugin.  Then it's time for a
    quickload plugin.

    The basic idea is that the plugin is loaded twice.  The first time user
    commands and mappings are defined that offer the functionality.  The second
    time the functions that implement the functionality are defined.

    It may sound surprising that quickload means loading a script twice.  What we
    mean is that it loads quickly the first time, postponing the bulk of the
    script to the second time, which only happens when you actually use it.  When
    you always use the functionality it actually gets slower!

    This uses a FuncUndefined autocommand.  Since Vim 7 there is an alternative:
    use the |autoload| functionality |41.15|.  That will also use |Vim9| script
    instead of legacy script that is used here.

    The following example shows how it's done:

    	" Vim global plugin for demonstrating quick loading
    	" Last Change:	2005 Feb 25
    	" Maintainer:	Bram Moolenaar <Bram@vim.org>
    	" License:	This file is placed in the public domain.

    	if !exists("s:did_load")
    		command -nargs=* BNRead  call BufNetRead(<f-args>)
    		map <F19> :call BufNetWrite('something')<CR>

    		let s:did_load = 1
    		exe 'au FuncUndefined BufNet* source ' .. expand('<sfile>')
    		finish
    	endif

    	function BufNetRead(...)
    		echo 'BufNetRead(' .. string(a:000) .. ')'
    		" read functionality here
    	endfunction

    	function BufNetWrite(...)
    		echo 'BufNetWrite(' .. string(a:000) .. ')'
    		" write functionality here
    	endfunction

    When the script is first loaded "s:did_load" is not set.  The commands between
    the "if" and "endif" will be executed.  This ends in a |:finish| command, thus
    the rest of the script is not executed.

    The second time the script is loaded "s:did_load" exists and the commands
    after the "endif" are executed.  This defines the (possible long)
    BufNetRead() and BufNetWrite() functions.

    If you drop this script in your plugin directory Vim will execute it on
    startup.  This is the sequence of events that happens:

    1. The "BNRead" command is defined and the <F19> key is mapped when the script
       is sourced at startup.  A |FuncUndefined| autocommand is defined.  The
       ":finish" command causes the script to terminate early.

    2. The user types the BNRead command or presses the <F19> key.  The
       BufNetRead() or BufNetWrite() function will be called.

    3. Vim can't find the function and triggers the |FuncUndefined| autocommand
       event.  Since the pattern "BufNet*" matches the invoked function, the
       command "source fname" will be executed.  "fname" will be equal to the name
       of the script, no matter where it is located, because it comes from
       expanding "<sfile>" (see |expand()|).

    4. The script is sourced again, the "s:did_load" variable exists and the
       functions are defined.

    Notice that the functions that are loaded afterwards match the pattern in the
    |FuncUndefined| autocommand.  You must make sure that no other plugin defines
    functions that match this pattern.

    *41.15*	Writing library scripts			*write-library-script*

    Some functionality will be required in several places.  When this becomes more
    than a few lines you will want to put it in one script and use it from many
    scripts.  We will call that one script a library script.

    Manually loading a library script is possible, so long as you avoid loading it
    when it's already done.  You can do this with the |exists()| function.
    Example:

    	if !exists('*MyLibFunction')
    	   runtime library/mylibscript.vim
    	endif
    	MyLibFunction(arg)

    Here you need to know that MyLibFunction() is defined in a script
    "library/mylibscript.vim" in one of the directories in 'runtimepath'.

    To make this a bit simpler Vim offers the autoload mechanism.  Then the
    example looks like this:

    	mylib#myfunction(arg)

    That's a lot simpler, isn't it?  Vim will recognize the function name by the
    embedded "#" character and when it's not defined search for the script
    "autoload/mylib.vim" in 'runtimepath'.  That script must define the
    "mylib#myfunction()" function.

    You can put many other functions in the mylib.vim script, you are free to
    organize your functions in library scripts.  But you must use function names
    where the part before the '#' matches the script name.  Otherwise Vim would
    not know what script to load.

    If you get really enthusiastic and write lots of library scripts, you may
    want to use subdirectories.  Example:

    	netlib#ftp#read('somefile')

    For Unix the library script used for this could be:

    	~/.vim/autoload/netlib/ftp.vim

    Where the function is defined like this:

    	def netlib#ftp#read(fname: string)
    		#  Read the file fname through ftp
    	enddef

    Notice that the name the function is defined with is exactly the same as the
    name used for calling the function.  And the part before the last '#'
    exactly matches the subdirectory and script name.

    You can use the same mechanism for variables:

    	var weekdays = dutch#weekdays

    This will load the script "autoload/dutch.vim", which should contain something
    like:

    	var dutch#weekdays = ['zondag', 'maandag', 'dinsdag', 'woensdag',
    		\ 'donderdag', 'vrijdag', 'zaterdag']

    Further reading: |autoload|.

    *41.16*	Distributing Vim scripts			*distribute-script*

    Vim users will look for scripts on the Vim website: http://www.vim.org.
    If you made something that is useful for others, share it!

    Another place is github.  But there you need to know where to find it!  The
    advantage is that most plugin managers fetch plugins from github.  You'll have
    to use your favorite search engine to find them.

    Vim scripts can be used on any system.  However, there might not be a tar or
    gzip command.  If you want to pack files together and/or compress them the
    "zip" utility is recommended.

    For utmost portability use Vim itself to pack scripts together.  This can be
    done with the Vimball utility.  See |vimball|.

    It's good if you add a line to allow automatic updating.  See |glvs-plugins|.

    Next chapter: |usr_42|  Add new menus

    Copyright: see |manual-copyright|  vim:tw=78:ts=8:noet:ft=help:norl:

Generated by vim2html on Thu, Feb 17, 2022 8:17:56 AM