vim: runtime/doc/eval.txt comparison

comparison runtime/doc/eval.txt @ 685:d7e33248b9c8 v7.0206

updated for version 7.0206

author	vimboss
date	Fri, 24 Feb 2006 23:53:04 +0000
parents	9364d114ed8d
children	bcd2edc4539e

comparison

equal deleted inserted replaced

-:a8caf7dd853d
+:d7e33248b9c8
-*eval.txt*      For Vim version 7.0aa.  Last change: 2006 Feb 22
+*eval.txt*      For Vim version 7.0aa.  Last change: 2006 Feb 24
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 	expr5 ==? expr5		equal, ignoring case
 	expr5 ==# expr5		equal, match case
 	etc.			As above, append ? for ignoring case, # for
 				matching case
-	expr5 is expr5		same List instance
+	expr5 is expr5		same |List| instance
-	expr5 isnot expr5	different List instance
+	expr5 isnot expr5	different |List| instance
 |expr5|	expr6 +	 expr6 ..	number addition or list concatenation
 	expr6 -	 expr6 ..	number subtraction
 	expr6 .	 expr6 ..	string concatenation
 |expr7|	! expr7			logical NOT
 	- expr7			unary minus
 	+ expr7			unary plus
-|expr8|	expr8[expr1]		byte of a String or item of a List
+|expr8|	expr8[expr1]		byte of a String or item of a |List|
-	expr8[expr1 : expr1]	substring of a String or sublist of a List
+	expr8[expr1 : expr1]	substring of a String or sublist of a |List|
-	expr8.name		entry in a Dictionary
+	expr8.name		entry in a |Dictionary|
-	expr8(expr1, ...)	function call with Funcref variable
+	expr8(expr1, ...)	function call with |Funcref| variable
 |expr9| number			number constant
 	"string"		string constant, backslash is special
 	'string'		string constant, ' is doubled
-	[expr1, ...]		List
+	[expr1, ...]		|List|
-	{expr1: expr1, ...}	Dictionary
+	{expr1: expr1, ...}	|Dictionary|
 	&option			option value
 	(expr1)			nested expression
 	variable		internal variable
 	va{ria}ble		internal variable with curly braces
 	$VAR			environment variable
 "abc" ==# "Abc"	  evaluates to 0
 "abc" ==? "Abc"	  evaluates to 1
 "abc" == "Abc"	  evaluates to 1 if 'ignorecase' is set, 0 otherwise
 							*E691* *E692*
-A List can only be compared with a List and only "equal", "not equal" and "is"
+A |List| can only be compared with a |List| and only "equal", "not equal" and
-can be used.  This compares the values of the list, recursively.  Ignoring
+"is" can be used.  This compares the values of the list, recursively.
-case means case is ignored when comparing item values.
+Ignoring case means case is ignored when comparing item values.
 							*E735* *E736*
-A Dictionary can only be compared with a Dictionary and only "equal", "not
+A |Dictionary| can only be compared with a |Dictionary| and only "equal", "not
-equal" and "is" can be used.  This compares the key/values of the Dictionary,
+equal" and "is" can be used.  This compares the key/values of the |Dictionary|
 recursively.  Ignoring case means case is ignored when comparing item values.
 							*E693* *E694*
-A Funcref can only be compared with a Funcref and only "equal" and "not equal"
+A |Funcref| can only be compared with a |Funcref| and only "equal" and "not
-can be used.  Case is never ignored.
+equal" can be used.  Case is never ignored.
-When using "is" or "isnot" with a List this checks if the expressions are
+When using "is" or "isnot" with a |List| this checks if the expressions are
-referring to the same List instance.  A copy of a List is different from the
+referring to the same |List| instance.  A copy of a |List| is different from
-original List.  When using "is" without a List it is equivalent to using
+the original |List|.  When using "is" without a |List| it is equivalent to
-"equal", using "isnot" equivalent to using "not equal".  Except that a
+using "equal", using "isnot" equivalent to using "not equal".  Except that a
 different type means the values are different.  "4 == '4'" is true, "4 is '4'"
 is false.
 When comparing a String with a Number, the String is converted to a Number,
 and the comparison is done on Numbers.  This means that "0 == 'x'" is TRUE,
 	"foo\nbar" =~ "\\n"	evaluates to 0
 expr5 and expr6						*expr5* *expr6*
 ---------------
-expr6 +	 expr6 ..	Number addition or List concatenation	*expr-+*
+expr6 +	 expr6 ..	Number addition or |List| concatenation	*expr-+*
 expr6 -	 expr6 ..	Number subtraction			*expr--*
 expr6 .	 expr6 ..	String concatenation			*expr-.*
-For Lists only "+" is possible and then both expr6 must be a list.  The result
+For |List|s only "+" is possible and then both expr6 must be a list.  The
-is a new list with the two lists Concatenated.
+result is a new list with the two lists Concatenated.
 expr7 *	 expr7 ..	number multiplication			*expr-star*
 expr7 /	 expr7 ..	number division				*expr-/*
 expr7 %	 expr7 ..	number modulo				*expr-%*
 	"123" . "456" = "123456"
 When the righthand side of '/' is zero, the result is 0x7fffffff.
 When the righthand side of '%' is zero, the result is 0.
-None of these work for Funcrefs.
+None of these work for |Funcref|s.
 expr7							*expr7*
 -----
 ! expr7			logical NOT		*expr-!*
 	--9	    == 9
 expr8							*expr8*
 -----
-expr8[expr1]		item of String or List		*expr-[]* *E111*
+expr8[expr1]		item of String or |List|	*expr-[]* *E111*
 If expr8 is a Number or String this results in a String that contains the
 expr1'th single byte from expr8.  expr8 is used as a String, expr1 as a
 Number.  Note that this doesn't recognize multi-byte encodings.
 If the length of the String is less than the index, the result is an empty
 String.  A negative index always results in an empty string (reason: backwards
 compatibility).  Use [-1:] to get the last byte.
-If expr8 is a List then it results the item at index expr1.  See |list-index|
+If expr8 is a |List| then it results the item at index expr1.  See |list-index|
 for possible index values.  If the index is out of range this results in an
 error.  Example: >
 	:let item = mylist[-1]		" get last item
-Generally, if a List index is equal to or higher than the length of the List,
+Generally, if a |List| index is equal to or higher than the length of the
-or more negative than the length of the List, this results in an error.
+|List|, or more negative than the length of the |List|, this results in an
+error.
 expr8[expr1a : expr1b]	substring or sublist		*expr-[:]*
 If expr8 is a Number or String this results in the substring with the bytes
 	:let c = name[-1:]		" last byte of a string
 	:let c = name[-2:-2]		" last but one byte of a string
 	:let s = line(".")[4:]		" from the fifth byte to the end
 	:let s = s[:-3]			" remove last two bytes
-If expr8 is a List this results in a new List with the items indicated by the
+If expr8 is a |List| this results in a new |List| with the items indicated by
-indexes expr1a and expr1b.  This works like with a String, as explained just
+the indexes expr1a and expr1b.  This works like with a String, as explained
-above, except that indexes out of range cause an error.  Examples: >
+just above, except that indexes out of range cause an error.  Examples: >
 	:let l = mylist[:3]		" first four items
 	:let l = mylist[4:4]		" List with one item
 	:let l = mylist[:]		" shallow copy of a List
-Using expr8[expr1] or expr8[expr1a : expr1b] on a Funcref results in an error.
+Using expr8[expr1] or expr8[expr1a : expr1b] on a |Funcref| results in an
+error.
-expr8.name		entry in a Dictionary		*expr-entry*
+expr8.name		entry in a |Dictionary|		*expr-entry*
-If expr8 is a Dictionary and it is followed by a dot, then the following name
-will be used as a key in the Dictionary.  This is just like: expr8[name].
+If expr8 is a |Dictionary| and it is followed by a dot, then the following
+name will be used as a key in the |Dictionary|.  This is just like:
+expr8[name].
 The name must consist of alphanumeric characters, just like a variable name,
 but it may start with a number.  Curly braces cannot be used.
 There must not be white space before or after the dot.
 Note that the dot is also used for String concatenation.  To avoid confusion
 always put spaces around the dot for String concatenation.
-expr8(expr1, ...)	Funcref function call
+expr8(expr1, ...)	|Funcref| function call
 When expr8 is a |Funcref| type variable, invoke the function it refers to.
 |local-variable|     l:	  Local to a function.
 |script-variable|    s:	  Local to a |:source|'ed Vim script.
 |function-argument|  a:	  Function argument (only inside a function).
 |vim-variable|       v:	  Global, predefined by Vim.
-The scope name by itself can be used as a Dictionary.  For example, to delete
+The scope name by itself can be used as a |Dictionary|.  For example, to
-all script-local variables: >
+delete all script-local variables: >
 	:for k in keys(s:)
 	:    unlet s:[k]
 	:endfor
 <
 						*buffer-variable* *b:var*
 			i	Insert mode
 			r	Replace mode
 			v	Virtual Replace mode
 						*v:key* *key-variable*
-v:key		Key of the current item of a Dictionary.  Only valid while
+v:key		Key of the current item of a |Dictionary|.  Only valid while
 		evaluating the expression used with |map()| and |filter()|.
 		Read-only.
 						*v:lang* *lang-variable*
 v:lang		The current locale setting for messages of the runtime
 	:  echo "Exception from" v:throwpoint
 	:endtry
 <		Output: "Exception from test.vim, line 2"
 						*v:val* *val-variable*
-v:val		Value of the current item of a List or Dictionary.  Only valid
+v:val		Value of the current item of a |List| or |Dictionary|.  Only
-		while evaluating the expression used with |map()| and
+		valid while evaluating the expression used with |map()| and
 		|filter()|.  Read-only.
 					*v:version* *version-variable*
 v:version	Version number of Vim: Major version number times 100 plus
 		minor version number.  Version 5.0 is 500.  Version 5.1 (5.01)
 (Use CTRL-] on the function name to jump to the full explanation.)
 USAGE				RESULT	DESCRIPTION	~
-add( {list}, {item})		List	append {item} to List {list}
+add( {list}, {item})		List	append {item} to |List| {list}
 append( {lnum}, {string})	Number	append {string} below line {lnum}
 append( {lnum}, {list})		Number	append lines {list} below line {lnum}
 argc()				Number	number of files in the argument list
 argidx()			Number	current index in the argument list
 argv( {nr})			String	{nr} entry of the argument list
 inputsave()			Number	save and clear typeahead
 inputsecret( {prompt} [, {text}]) String  like input() but hiding the text
 insert( {list}, {item} [, {idx}]) List	insert {item} in {list} [before {idx}]
 isdirectory( {directory})	Number	TRUE if {directory} is a directory
 islocked( {expr})		Number	TRUE if {expr} is locked
-items( {dict})			List	List of key-value pairs in {dict}
+items( {dict})			List	key-value pairs in {dict}
 join( {list} [, {sep}])		String	join {list} items into one String
-keys( {dict})			List	List of keys in {dict}
+keys( {dict})			List	keys in {dict}
 len( {expr})			Number	the length of {expr}
 libcall( {lib}, {func}, {arg})	String	call {func} in library {lib} with {arg}
 libcallnr( {lib}, {func}, {arg})  Number  idem, but return a Number
 line( {expr})			Number	line nr of cursor, last line or mark
 line2byte( {lnum})		Number	byte count of line {lnum}
 soundfold( {word})		String	sound-fold {word}
 spellbadword()			String	badly spelled word at cursor
 spellsuggest( {word} [, {max} [, {capital}]])
 				List	spelling suggestions
 split( {expr} [, {pat} [, {keepempty}]])
-				List	make List from {pat} separated {expr}
+				List	make |List| from {pat} separated {expr}
 strftime( {format}[, {time}])	String	time in specified format
 stridx( {haystack}, {needle}[, {start}])
 				Number	index of {needle} in {haystack}
 string( {expr})			String	String representation of {expr} value
 strlen( {expr})			Number	length of the String {expr}
 tolower( {expr})		String	the String {expr} switched to lowercase
 toupper( {expr})		String	the String {expr} switched to uppercase
 tr( {src}, {fromstr}, {tostr})	String	translate chars of {src} in {fromstr}
 					to chars in {tostr}
 type( {name})			Number	type of variable {name}
-values( {dict})			List	List of values in {dict}
+values( {dict})			List	values in {dict}
 virtcol( {expr})		Number	screen column of cursor or mark
 visualmode( [expr])		String	last visual mode used
 winbufnr( {nr})			Number	buffer number of window {nr}
 wincol()			Number	window column of the cursor
 winheight( {nr})		Number	height of window {nr}
 winwidth( {nr})			Number	width of window {nr}
 writefile({list}, {fname} [, {binary}])
 				Number	write list of lines to file {fname}
 add({list}, {expr})					*add()*
-		Append the item {expr} to List {list}.  Returns the resulting
+		Append the item {expr} to |List| {list}.  Returns the
-		List.  Examples: >
+		resulting |List|.  Examples: >
 			:let alist = add([1, 2, 3], item)
 			:call add(mylist, "woodstock")
-<		Note that when {expr} is a List it is appended as a single
+<		Note that when {expr} is a |List| it is appended as a single
-		item.  Use |extend()| to concatenate Lists.
+		item.  Use |extend()| to concatenate |List|s.
 		Use |insert()| to add an item at another position.
 append({lnum}, {expr})					*append()*
-		When {expr} is a List: Append each item of the List as a text
+		When {expr} is a |List|: Append each item of the |List| as a
-		line below line {lnum} in the current buffer.
+		text line below line {lnum} in the current buffer.
 		Otherwise append {expr} as one text line below line {lnum} in
 		the current buffer.
 		{lnum} can be zero to insert a line before the first one.
 		Returns 1 for failure ({lnum} out of range or out of memory),
 		0 for success.  Example: >
 <		If there are less than {nr} characters -1 is returned.
 		If there are exactly {nr} characters the length of the string
 		is returned.
 call({func}, {arglist} [, {dict}])			*call()* *E699*
-		Call function {func} with the items in List {arglist} as
+		Call function {func} with the items in |List| {arglist} as
 		arguments.
-		{func} can either be a Funcref or the name of a function.
+		{func} can either be a |Funcref| or the name of a function.
 		a:firstline and a:lastline are set to the cursor line.
 		Returns the return value of the called function.
 		{dict} is for functions with the "dict" attribute.  It will be
 		used to set the local variable "self". |Dictionary-function|
 		the horizontal layout is always used.
 							*copy()*
 copy({expr})	Make a copy of {expr}.  For Numbers and Strings this isn't
 		different from using {expr} directly.
-		When {expr} is a List a shallow copy is created.  This means
+		When {expr} is a |List| a shallow copy is created.  This means
-		that the original List can be changed without changing the
+		that the original |List| can be changed without changing the
 		copy, and vise versa.  But the items are identical, thus
-		changing an item changes the contents of both Lists.  Also see
+		changing an item changes the contents of both |List|s.  Also
-		|deepcopy()|.
+		see |deepcopy()|.
 count({comp}, {expr} [, {ic} [, {start}]])			*count()*
 		Return the number of times an item with value {expr} appears
-		in List or Dictionary {comp}.
+		in |List| or |Dictionary| {comp}.
 		If {start} is given then start with the item with this index.
-		{start} can only be used with a List.
+		{start} can only be used with a |List|.
 		When {ic} is given and it's non-zero then case is ignored.
 							*cscope_connection()*
 cscope_connection([{num} , {dbpath} [, {prepend}]])
 deepcopy({expr}[, {noref}])				*deepcopy()* *E698*
 		Make a copy of {expr}.  For Numbers and Strings this isn't
 		different from using {expr} directly.
-		When {expr} is a List a full copy is created.  This means
+		When {expr} is a |List| a full copy is created.  This means
-		that the original List can be changed without changing the
+		that the original |List| can be changed without changing the
-		copy, and vise versa.  When an item is a List, a copy for it
+		copy, and vise versa.  When an item is a |List|, a copy for it
 		is made, recursively.  Thus changing an item in the copy does
-		not change the contents of the original List.
+		not change the contents of the original |List|.
-		When {noref} is omitted or zero a contained List or Dictionary
+		When {noref} is omitted or zero a contained |List| or
-		is only copied once.  All references point to this single
+		|Dictionary| is only copied once.  All references point to
-		copy.  With {noref} set to 1 every occurrence of a List or
+		this single copy.  With {noref} set to 1 every occurrence of a
-		Dictionary results in a new copy.  This also means that a
+		|List| or |Dictionary| results in a new copy.  This also means
-		cyclic reference causes deepcopy() to fail.
+		that a cyclic reference causes deepcopy() to fail.
 								*E724*
 		Nesting is possible up to 100 levels.  When there is an item
 		that refers back to a higher level making a deep copy with
 		{noref} set to 1 will fail.
 		Also see |copy()|.
 delete({fname})							*delete()*
 		Deletes the file by the name {fname}.  The result is a Number,
 		which is 0 if the file was deleted successfully, and non-zero
 		when the deletion failed.
-		Use |remove()| to delete an item from a List.
+		Use |remove()| to delete an item from a |List|.
 							*did_filetype()*
 did_filetype()	Returns non-zero when autocommands are being executed and the
 		FileType event has been triggered at least once.  Can be used
 		to avoid triggering the FileType event again in the scripts
 		The highlight ID can be used with |synIDattr()| to obtain
 		syntax information about the highlighting.
 empty({expr})						*empty()*
 		Return the Number 1 if {expr} is empty, zero otherwise.
-		A List or Dictionary is empty when it does not have any items.
+		A |List| or |Dictionary| is empty when it does not have any
-		A Number is empty when its value is zero.
+		items.  A Number is empty when its value is zero.
-		For a long List this is much faster then comparing the length
+		For a long |List| this is much faster then comparing the
-		with zero.
+		length with zero.
 escape({string}, {chars})				*escape()*
 		Escape the characters in {chars} that occur in {string} with a
 		backslash.  Example: >
 			:echo escape('c:\program files\vim', ' \')
 <							*eval()*
 eval({string})	Evaluate {string} and return the result.  Especially useful to
 		turn the result of |string()| back into the original value.
 		This works for Numbers, Strings and composites of them.
-		Also works for Funcrefs that refer to existing functions.
+		Also works for |Funcref|s that refer to existing functions.
 eventhandler()						*eventhandler()*
 		Returns 1 when inside an event handler.  That is that Vim got
 		interrupted while waiting for the user to type a character,
 		e.g., when dropping a file on Vim.  This means interactive
 			*funcname	built-in function (see |functions|)
 					or user defined function (see
 					|user-functions|).
 			varname		internal variable (see
 					|internal-variables|).  Also works
-					for |curly-braces-names|, Dictionary
+					for |curly-braces-names|, |Dictionary|
-					entries, List items, etc.  Beware that
+					entries, |List| items, etc.  Beware
-					this may cause functions to be
+					that this may cause functions to be
 					invoked cause an error message for an
 					invalid expression.
 			:cmdname	Ex command: built-in command, user
 					command or command modifier |:command|.
 					Returns:
 		See |glob()| for finding existing files.  See |system()| for
 		getting the raw output of an external command.
 extend({expr1}, {expr2} [, {expr3}])			*extend()*
-		{expr1} and {expr2} must be both Lists or both Dictionaries.
+		{expr1} and {expr2} must be both |List|s or both Dictionaries.
-		If they are Lists: Append {expr2} to {expr1}.
+		If they are |List|s: Append {expr2} to {expr1}.
 		If {expr3} is given insert the items of {expr2} before item
 		{expr3} in {expr1}.  When {expr3} is zero insert before the
 		first item.  When {expr3} is equal to len({expr1}) then
 		{expr2} is appended.
 		Examples: >
 							*file_readable()*
 		Obsolete name: file_readable().
 filter({expr}, {string})					*filter()*
-		{expr} must be a List or a Dictionary.
+		{expr} must be a |List| or a |Dictionary|.
 		For each item in {expr} evaluate {string} and when the result
-		is zero remove the item from the List or Dictionary.
+		is zero remove the item from the |List| or |Dictionary|.
 		Inside {string} |v:val| has the value of the current item.
-		For a Dictionary |v:key| has the key of the current item.
+		For a |Dictionary| |v:key| has the key of the current item.
 		Examples: >
 			:call filter(mylist, 'v:val !~ "OLD"')
 <		Removes the items where "OLD" appears. >
 			:call filter(mydict, 'v:key >= 8')
 <		Removes the items with a key below 8. >
 			:call filter(var, 0)
-<		Removes all the items, thus clears the List or Dictionary.
+<		Removes all the items, thus clears the |List| or |Dictionary|.
 		Note that {string} is the result of expression and is then
 		used as an expression again.  Often it is good to use a
 		|literal-string| to avoid having to double backslashes.
-		The operation is done in-place.  If you want a List or
+		The operation is done in-place.  If you want a |List| or
-		Dictionary to remain unmodified make a copy first: >
+		|Dictionary| to remain unmodified make a copy first: >
 			:let l = filter(copy(mylist), 'v:val =~ "KEEP"')
-<		Returns {expr}, the List or Dictionary that was filtered.
+<		Returns {expr}, the |List| or |Dictionary| that was filtered.
 		When an error is encountered while evaluating {string} no
 		further items in {expr} are processed.
 finddir({name}[, {path}[, {count}]])				*finddir()*
 		{only in the Win32, Athena, Motif and GTK GUI versions and the
 		Win32 console version}
 function({name})					*function()* *E700*
-		Return a Funcref variable that refers to function {name}.
+		Return a |Funcref| variable that refers to function {name}.
 		{name} can be a user defined function or an internal function.
 garbagecollect()					*garbagecollect()*
-		Cleanup unused Lists and Dictionaries that have circular
+		Cleanup unused |List|s and Dictionaries that have circular
 		references.  There is hardly ever a need to invoke this
 		function, as it is automatically done when Vim runs out of
 		memory or is waiting for the user to press a key after
 		'updatetime'.  Items without circular references are always
 		freed when they become unused.
-		This is useful if you have deleted a very big List and/or
+		This is useful if you have deleted a very big |List| and/or
-		Dictionary with circular references in a script that runs for
+		|Dictionary| with circular references in a script that runs
-		a long time.
+		for a long time.
 get({list}, {idx} [, {default}])			*get()*
-		Get item {idx} from List {list}.  When this item is not
+		Get item {idx} from |List| {list}.  When this item is not
 		available return {default}.  Return zero when {default} is
 		omitted.
 get({dict}, {key} [, {default}])
-		Get item with key {key} from Dictionary {dict}.  When this
+		Get item with key {key} from |Dictionary| {dict}.  When this
 		item is not available return {default}.  Return zero when
 		{default} is omitted.
 							*getbufline()*
 getbufline({expr}, {lnum} [, {end}])
-		Return a List with the lines starting from {lnum} to {end}
+		Return a |List| with the lines starting from {lnum} to {end}
-		(inclusive) in the buffer {expr}.  If {end} is omitted, a List
+		(inclusive) in the buffer {expr}.  If {end} is omitted, a
-		with only the line {lnum} is returned.
+		|List| with only the line {lnum} is returned.
 		For the use of {expr}, see |bufname()| above.
 		For {lnum} and {end} "$" can be used for the last line of the
 		buffer.  Otherwise a number must be used.
 		When {lnum} is smaller than 1 or bigger than the number of
-		lines in the buffer, an empty List is returned.
+		lines in the buffer, an empty |List| is returned.
 		When {end} is greater than the number of lines in the buffer,
 		it is treated as {end} is set to the number of lines in the
-		buffer.  When {end} is before {lnum} an empty List is
+		buffer.  When {end} is before {lnum} an empty |List| is
 		returned.
 		This function works only for loaded buffers.  For unloaded and
-		non-existing buffers, an empty List is returned.
+		non-existing buffers, an empty |List| is returned.
 		Example: >
 			:let lines = getbufline(bufnr("myfile"), 1, "$")
 getbufvar({expr}, {varname})				*getbufvar()*
 		To get the line under the cursor: >
 			getline(".")
 <		When {lnum} is smaller than 1 or bigger than the number of
 		lines in the buffer, an empty string is returned.
-		When {end} is given the result is a List where each item is a
+		When {end} is given the result is a |List| where each item is
-		line from the current buffer in the range {lnum} to {end},
+		a line from the current buffer in the range {lnum} to {end},
 		including line {end}.
 		{end} is used in the same way as {lnum}.
 		Non-existing lines are silently omitted.
-		When {end} is before {lnum} an empty List is returned.
+		When {end} is before {lnum} an empty |List| is returned.
 		Example: >
 			:let start = line('.')
 			:let end = search("^$") - 1
 			:let lines = getline(start, end)
 		string.  See |feature-list| below.
 		Also see |exists()|.
 has_key({dict}, {key})					*has_key()*
-		The result is a Number, which is 1 if Dictionary {dict} has an
+		The result is a Number, which is 1 if |Dictionary| {dict} has
-		entry with key {key}.  Zero otherwise.
+		an entry with key {key}.  Zero otherwise.
 hasmapto({what} [, {mode}])				*hasmapto()*
 		The result is a Number, which is 1 if there is a mapping that
 		contains {what} in somewhere in the rhs (what it is mapped to)
 		|getline()|.
 		When {lnum} is invalid -1 is returned.
 index({list}, {expr} [, {start} [, {ic}]])			*index()*
-		Return the lowest index in List {list} where the item has a
+		Return the lowest index in |List| {list} where the item has a
 		value equal to {expr}.
 		If {start} is given then start looking at the item with index
 		{start} (may be negative for an item relative to the end).
 		When {ic} is given and it is non-zero, ignore case.  Otherwise
 		case must match.
 		The result is a String, which is whatever the user actually
 		typed on the command-line in response to the issued prompt.
 		NOTE: Command-line completion is not supported.
 insert({list}, {item} [, {idx}])			*insert()*
-		Insert {item} at the start of List {list}.
+		Insert {item} at the start of |List| {list}.
 		If {idx} is specified insert {item} before the item with index
 		{idx}.  If {idx} is zero it goes before the first item, just
 		like omitting {idx}.  A negative {idx} is also possible, see
 		|list-index|.  -1 inserts just before the last item.
-		Returns the resulting List.  Examples: >
+		Returns the resulting |List|.  Examples: >
 			:let mylist = insert([2, 3, 5], 1)
 			:call insert(mylist, 4, -1)
 			:call insert(mylist, 6, len(mylist))
 <		The last example can be done simpler with |add()|.
-		Note that when {item} is a List it is inserted as a single
+		Note that when {item} is a |List| it is inserted as a single
-		item.  Use |extend()| to concatenate Lists.
+		item.  Use |extend()| to concatenate |List|s.
 isdirectory({directory})				*isdirectory()*
 		The result is a Number, which is non-zero when a directory
 		with the name {directory} exists.  If {directory} doesn't
 		exist, or isn't a directory, the result is FALSE.  {directory}
 		is any expression, which is used as a String.
 islocked({expr})					*islocked()*
 		The result is a Number, which is non-zero when {expr} is the
 		name of a locked variable.
-		{expr} must be the name of a variable, List item or Dictionary
+		{expr} must be the name of a variable, |List| item or
-		entry, not the variable itself!  Example: >
+		|Dictionary| entry, not the variable itself!  Example: >
 			:let alist = [0, ['a', 'b'], 2, 3]
 			:lockvar 1 alist
 			:echo islocked('alist')		" 1
 			:echo islocked('alist[1]')	" 0
 <		When {expr} is a variable that does not exist you get an error
 		message.  Use |exists()| to check for existance.
 items({dict})						*items()*
-		Return a List with all the key-value pairs of {dict}.  Each
+		Return a |List| with all the key-value pairs of {dict}.  Each
-		List item is a list with two items: the key of a {dict} entry
+		|List| item is a list with two items: the key of a {dict}
-		and the value of this entry.  The List is in arbitrary order.
+		entry and the value of this entry.  The |List| is in arbitrary
+		order.
 join({list} [, {sep}])					*join()*
 		Join the items in {list} together into one String.
 		When {sep} is specified it is put in between the items.  If
 		{sep} is omitted a single space is used.
 		Note that {sep} is not added at the end.  You might want to
 		add it there too: >
 			let lines = join(mylist, "\n") . "\n"
-<		String items are used as-is.  Lists and Dictionaries are
+<		String items are used as-is.  |List|s and Dictionaries are
 		converted into a string like with |string()|.
 		The opposite function is |split()|.
 keys({dict})						*keys()*
-		Return a List with all the keys of {dict}.  The List is in
+		Return a |List| with all the keys of {dict}.  The |List| is in
 		arbitrary order.
 							*len()* *E701*
 len({expr})	The result is a Number, which is the length of the argument.
 		When {expr} is a String or a Number the length in bytes is
 		used, as with |strlen()|.
-		When {expr} is a List the number of items in the List is
+		When {expr} is a |List| the number of items in the |List| is
 		returned.
-		When {expr} is a Dictionary the number of entries in the
+		When {expr} is a |Dictionary| the number of entries in the
-		Dictionary is returned.
+		|Dictionary| is returned.
 		Otherwise an error is given.
 						*libcall()* *E364* *E368*
 libcall({libname}, {funcname}, {argument})
 		Call function {funcname} in the run-time library {libname}
 		Return the current time, measured as seconds since 1st Jan
 		1970.  See also |strftime()| and |getftime()|.
 map({expr}, {string})					*map()*
-		{expr} must be a List or a Dictionary.
+		{expr} must be a |List| or a |Dictionary|.
 		Replace each item in {expr} with the result of evaluating
 		{string}.
 		Inside {string} |v:val| has the value of the current item.
-		For a Dictionary |v:key| has the key of the current item.
+		For a |Dictionary| |v:key| has the key of the current item.
 		Example: >
 			:call map(mylist, '"> " . v:val . " <"')
 <		This puts "> " before and " <" after each item in "mylist".
 		Note that {string} is the result of an expression and is then
 		used as an expression again.  Often it is good to use a
 		|literal-string| to avoid having to double backslashes.  You
 		still have to double ' quotes
-		The operation is done in-place.  If you want a List or
+		The operation is done in-place.  If you want a |List| or
-		Dictionary to remain unmodified make a copy first: >
+		|Dictionary| to remain unmodified make a copy first: >
 			:let tlist = map(copy(mylist), ' & . "\t"')
-<		Returns {expr}, the List or Dictionary that was filtered.
+<		Returns {expr}, the |List| or |Dictionary| that was filtered.
 		When an error is encountered while evaluating {string} no
 		further items in {expr} are processed.
 maparg({name}[, {mode}])				*maparg()*
 	:endif
 <		This avoids adding the "_vv" mapping when there already is a
 		mapping for "_v" or for "_vvv".
 match({expr}, {pat}[, {start}[, {count}]])			*match()*
-		When {expr} is a List then this returns the index of the first
+		When {expr} is a |List| then this returns the index of the
-		item where {pat} matches.  Each item is used as a String,
+		first item where {pat} matches.  Each item is used as a
-		Lists and Dictionaries are used as echoed.
+		String, |List|s and Dictionaries are used as echoed.
 		Otherwise, {expr} is used as a String.  The result is a
 		Number, which gives the index (byte offset) in {expr} where
 		{pat} matches.
-		A match at the first character or List item returns zero.
+		A match at the first character or |List| item returns zero.
 		If there is no match -1 is returned.
 		Example: >
 			:echo match("testing", "ing")	" results in 4
 			:echo match([1, 'x'], '\a')	" results in 2
 <		See |string-match| for how {pat} is used.
 <
 		When {count} is given use the {count}'th match.  When a match
 		is found in a String the search for the next one starts on
 		character further.  Thus this example results in 1: >
 			echo match("testing", "..", 0, 2)
-<		In a List the search continues in the next item.
+<		In a |List| the search continues in the next item.
 		If {start} is given, the search starts from byte index
-		{start} in a String or item {start} in a List.
+		{start} in a String or item {start} in a |List|.
 		The result, however, is still the index counted from the
 		first character/item.  Example: >
 			:echo match("testing", "ing", 2)
 <		result is again "4". >
 			:echo match("testing", "ing", 4)
 			:echo match("testing", "t", 2)
 <		result is "3".
 		For a String, if {start} < 0, it will be set to 0.  For a list
 		the index is counted from the end.
 		If {start} is out of range (> strlen({expr} for a String or
-		> len({expr} for a List) -1 is returned.
+		> len({expr} for a |List|) -1 is returned.
 		See |pattern| for the patterns that are accepted.
 		The 'ignorecase' option is used to set the ignore-caseness of
 		the pattern.  'smartcase' is NOT used.  The matching is always
 		done like 'magic' is set and 'cpoptions' is empty.
 		The {start}, if given, has the same meaning as for match(). >
 			:echo matchend("testing", "ing", 2)
 <		results in "7". >
 			:echo matchend("testing", "ing", 5)
 <		result is "-1".
-		When {expr} is a List the result is equal to match().
+		When {expr} is a |List| the result is equal to match().
 matchlist({expr}, {pat}[, {start}[, {count}]])			*matchlist()*
-		Same as match(), but return a List.  The first item in the
+		Same as match(), but return a |List|.  The first item in the
 		list is the matched string, same as what matchstr() would
 		return.  Following items are submatches, like "\1", "\2", etc.
 		in |:substitute|.
 		When there is no match an empty list is returned.
 		The {start}, if given, has the same meaning as for match(). >
 			:echo matchstr("testing", "ing", 2)
 <		results in "ing". >
 			:echo matchstr("testing", "ing", 5)
 <		result is "".
-		When {expr} is a List then the matching item is returned.
+		When {expr} is a |List| then the matching item is returned.
 		The type isn't changed, it's not necessarily a String.
 							*max()*
 max({list})	Return the maximum value of all items in {list}.
 		If {list} is not a list or one of the items in {list} cannot
 		be used as a Number this results in an error.
-		An empty List results in zero.
+		An empty |List| results in zero.
 							*min()*
 min({list})	Return the minumum value of all items in {list}.
 		If {list} is not a list or one of the items in {list} cannot
 		be used as a Number this results in an error.
-		An empty List results in zero.
+		An empty |List| results in zero.
 							*mkdir()* *E749*
 mkdir({name} [, {path} [, {prot}]])
 		Create directory {name}.
 		If {path} is "p" then intermediate directories are created as
 		otherwise.  See |ins-completion-menu|.
 							*E726* *E727*
 range({expr} [, {max} [, {stride}]])				*range()*
-		Returns a List with Numbers:
+		Returns a |List| with Numbers:
 		- If only {expr} is specified: [0, 1, ..., {expr} - 1]
 		- If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
 		- If {stride} is specified: [{expr}, {expr} + {stride}, ...,
 		  {max}] (increasing {expr} with {stride} each time, not
 		  producing a value past {max}).
 			range(0)		" []
 			range(2, 0)		" error!
 <
 							*readfile()*
 readfile({fname} [, {binary} [, {max}]])
-		Read file {fname} and return a List, each line of the file as
+		Read file {fname} and return a |List|, each line of the file
-		an item.  Lines broken at NL characters.  Macintosh files
+		as an item.  Lines broken at NL characters.  Macintosh files
 		separated with CR will result in a single long line (unless a
 		NL appears somewhere).
 		When {binary} is equal to "b" binary mode is used:
 		- When the last line ends in a NL an extra empty list item is
 		  added.
 		 \ echo remote_read(expand("<amatch>"))
 		:echo remote_send("gvim", ":sleep 10 | echo ".
 		 \ 'server2client(expand("<client>"), "HELLO")<CR>')
 <
 remove({list}, {idx} [, {end}])				*remove()*
-		Without {end}: Remove the item at {idx} from List {list} and
+		Without {end}: Remove the item at {idx} from |List| {list} and
 		return it.
 		With {end}: Remove items from {idx} to {end} (inclusive) and
 		return a list with these items.  When {idx} points to the same
 		item as {end} a list with one item is returned.  When {end}
 		points to an item before {idx} this is an error.
 repeat({expr}, {count})					*repeat()*
 		Repeat {expr} {count} times and return the concatenated
 		result.  Example: >
 			:let seperator = repeat('-', 80)
 <		When {count} is zero or negative the result is empty.
-		When {expr} is a List the result is {expr} concatenated
+		When {expr} is a |List| the result is {expr} concatenated
 		{count} times.  Example: >
 			:let longlist = repeat(['a', 'b'], 3)
 <		Results in ['a', 'b', 'a', 'b', 'a', 'b'].
 	:echo searchpair('{', '', '}', 'bW',
 	     \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
 <
 							*searchpairpos()*
 searchpairpos({start}, {middle}, {end} [, {flags} [, {skip}]])
-		Same as searchpair(), but returns a List with the line and
+		Same as searchpair(), but returns a |List| with the line and
-		column position of the match. The first element of the List is
+		column position of the match. The first element of the |List|
-		the line number and the second element is the byte index of
+		is the line number and the second element is the byte index of
 		the column position of the match.  If no match is found,
 		returns [0, 0].
 >
 			:let [lnum,col] = searchpairpos('{', '', '}', 'n')
 <
 		See |match-parens| for a bigger and more useful example.
 searchpos({pattern} [, {flags}])			*searchpos()*
-		Same as search(), but returns a List with the line and column
+		Same as search(), but returns a |List| with the line and
-		position of the match. The first element of the List is the
+		column position of the match. The first element of the |List|
-		line number and the second element is the byte index of the
+		is the line number and the second element is the byte index of
-		column position of the match. If no match is found, returns
+		the column position of the match. If no match is found,
-		[0, 0].
+		returns [0, 0].
 >
 			:let [lnum,col] = searchpos('mypattern', 'n')
 <
 server2client( {clientid}, {string})			*server2client()*
 		Send a reply string to {clientid}.  The most recent {clientid}
 		When {lnum} is just below the last line the {line} will be
 		added as a new line.
 		If this succeeds, 0 is returned.  If this fails (most likely
 		because {lnum} is invalid) 1 is returned.  Example: >
 			:call setline(5, strftime("%c"))
-<		When {line} is a List then line {lnum} and following lines
+<		When {line} is a |List| then line {lnum} and following lines
 		will be set to the items in the list.  Example: >
 			:call setline(5, ['aaa', 'bbb', 'ccc'])
 <		This is equivalent to: >
 			:for [n, l] in [[5, 6, 7], ['aaa', 'bbb', 'ccc']]
 			:  call setline(n, l)
 sort({list} [, {func}])					*sort()* *E702*
 		Sort the items in {list} in-place.  Returns {list}.  If you
 		want a list to remain unmodified make a copy first: >
 			:let sortedlist = sort(copy(mylist))
 <		Uses the string representation of each item to sort on.
-		Numbers sort after Strings, Lists after Numbers.
+		Numbers sort after Strings, |List|s after Numbers.
 		For sorting text in the current buffer use |:sort|.
 		When {func} is given and it is one then case is ignored.
-		When {func} is a Funcref or a function name, this function is
+		When {func} is a |Funcref| or a function name, this function
-		called to compare items.  The function is invoked with two
+		is called to compare items.  The function is invoked with two
 		items as argument and must return zero if they are equal, 1 if
 		the first one sorts after the second one, -1 if the first one
 		sorts before the second one.  Example: >
 			func MyCompare(i1, i2)
 			   return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
 		'spell' option must be set and the value of 'spelllang' is
 		used.
 							*spellsuggest()*
 spellsuggest({word} [, {max} [, {capital}]])
-		Return a List with spelling suggestions to replace {word}.
+		Return a |List| with spelling suggestions to replace {word}.
 		When {max} is given up to this number of suggestions are
 		returned.  Otherwise up to 25 suggestions are returned.
 		When the {capital} argument is given and it's non-zero only
 		suggestions with a leading capital will be given.  Use this
 		'spell' option must be set and the values of 'spelllang' and
 		'spellsuggest' are used.
 split({expr} [, {pattern} [, {keepempty}]])			*split()*
-		Make a List out of {expr}.  When {pattern} is omitted or empty
+		Make a |List| out of {expr}.  When {pattern} is omitted or
-		each white-separated sequence of characters becomes an item.
+		empty each white-separated sequence of characters becomes an
+		item.
 		Otherwise the string is split where {pattern} matches,
 		removing the matched characters.
 		When the first or last item is empty it is omitted, unless the
 		{keepempty} argument is given and it's non-zero.
 		Other empty items are kept when {pattern} matches at least one
 		Unlike ":!cmd" there is no automatic check for changed files.
 		Use |:checktime| to force a check.
 tabpagebuflist([{arg}])					*tabpagebuflist()*
-		The result is a List, where each item is the number of the
+		The result is a |List|, where each item is the number of the
 		buffer associated with each window in the current tab page.
 		{arg} specifies the number of tab page to be used.  When
 		omitted the current tab page is used.
 		When {arg} is invalid the number zero is returned.
 		To get a list of all buffers in all tabs use this: >
 		Refer to |'tags'| for information about how the tags file is
 		located by Vim. Refer to |tags-file-format| for the format of
 		the tags file generated by the different ctags tools.
 							*tagfiles()*
-tagfiles()	Returns a List with the file names used to search for tags for
+tagfiles()	Returns a |List| with the file names used to search for tags
-		the current buffer.  This is the 'tags' option expanded.
+		for the current buffer.  This is the 'tags' option expanded.
 tempname()					*tempname()* *temp-file-name*
 		The result is a String, which is the name of a file that
 		doesn't exist.  It can be used for a temporary file.  The name
 			:if type(myvar) == type(function("tr"))
 			:if type(myvar) == type([])
 			:if type(myvar) == type({})
 values({dict})						*values()*
-		Return a List with all the values of {dict}.  The List is in
+		Return a |List| with all the values of {dict}.  The |List| is
-		arbitrary order.
+		in arbitrary order.
 virtcol({expr})						*virtcol()*
 		The result is a Number, which is the screen column of the file
 		position given with {expr}.  That is, the last screen position
 		occupied by the character at that position, when the screen
 		would be of unlimited width.  When there is a <Tab> at the
 		position, the returned Number will be the column at the end of
 		the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
 		set to 8, it returns 8.
+		For the use of {expr} see |col()|.  Additionally you can use
+		[lnum, col]: a |List| with the line and column number.
 		For the byte position use |col()|.
 		When Virtual editing is active in the current mode, a position
 		beyond the end of the line can be returned. |'virtualedit'|
 		The accepted positions are:
 		    .	    the cursor position
 :  exe "normal 50\<C-W>|"
 :endif
 <
 							*writefile()*
 writefile({list}, {fname} [, {binary}])
-		Write List {list} to file {fname}.  Each list item is
+		Write |List| {list} to file {fname}.  Each list item is
 		separated with a NL.  Each list item must be a String or
 		Number.
 		When {binary} is equal to "b" binary mode is used: There will
 		not be a NL after the last list item.  An empty item at the
 		end does cause the last line in the file to end in a NL.
 					*:fu* *:function* *E128* *E129* *E123*
 :fu[nction]		List all functions and their arguments.
 :fu[nction] {name}	List function {name}.
-			{name} can also be a Dictionary entry that is a
+			{name} can also be a |Dictionary| entry that is a
-			Funcref: >
+			|Funcref|: >
 				:function dict.init
 :fu[nction] /{pattern}	List functions with a name matching {pattern}.
 			Example that lists all functions ending with "File": >
 				:function /File$
 :fu[nction][!] {name}([arguments]) [range] [abort] [dict]
 			Define a new function by the name {name}.  The name
 			must be made of alphanumeric characters and '_', and
 			must start with a capital or "s:" (see above).
-			{name} can also be a Dictionary entry that is a
+			{name} can also be a |Dictionary| entry that is a
-			Funcref: >
+			|Funcref|: >
 				:function dict.init(arg)
 <			"dict" must be an existing dictionary.  The entry
 			"init" is added if it didn't exist yet.  Otherwise [!]
 			is required to overwrite an existing function.  The
 			result is a |Funcref| to a numbered function.  The
 			When the [abort] argument is added, the function will
 			abort as soon as an error is detected.
 			When the [dict] argument is added, the function must
-			be invoked through an entry in a Dictionary.  The
+			be invoked through an entry in a |Dictionary|.  The
 			local variable "self" will then be set to the
 			dictionary.  See |Dictionary-function|.
 			The last used search pattern and the redo command "."
 			will not be changed by the function.
 :endf[unction]		The end of a function definition.  Must be on a line
 			by its own, without other commands.
 					*:delf* *:delfunction* *E130* *E131*
 :delf[unction] {name}	Delete function {name}.
-			{name} can also be a Dictionary entry that is a
+			{name} can also be a |Dictionary| entry that is a
-			Funcref: >
+			|Funcref|: >
 				:delfunc dict.init
 <			This will remove the "init" entry from "dict".  The
 			function is deleted if there are no more references to
 			it.
 							*:retu* *:return* *E133*
 						*a:0* *a:1* *a:000* *E740*
 Up to 20 arguments can be given, separated by commas.  After the named
 arguments an argument "..." can be specified, which means that more arguments
 may optionally be following.  In the function the extra arguments can be used
 as "a:1", "a:2", etc.  "a:0" is set to the number of extra arguments (which
-can be 0).  "a:000" is set to a List that contains these arguments.  Note that
+can be 0).  "a:000" is set to a |List| that contains these arguments.  Note
-"a:1" is the same as "a:000[0]".
+that "a:1" is the same as "a:000[0]".
 								*E742*
 The a: scope and the variables in it cannot be changed, they are fixed.
-However, if a List or Dictionary is used, you can changes their contents.
+However, if a |List| or |Dictionary| is used, you can changes their contents.
-Thus you can pass a List to a function and have the function add an item to
+Thus you can pass a |List| to a function and have the function add an item to
-it.  If you want to make sure the function cannot change a List or Dictionary
+it.  If you want to make sure the function cannot change a |List| or
-use |:lockvar|.
+|Dictionary| use |:lockvar|.
 When not using "...", the number of arguments in a function call must be equal
 to the number of named arguments.  When using "...", the number of arguments
 may be larger.
 			the index can be repeated.
 			This cannot be used to add an item to a list.
 							*E711* *E719*
 :let {var-name}[{idx1}:{idx2}] = {expr1}		*E708* *E709* *E710*
-			Set a sequence of items in a List to the result of the
+			Set a sequence of items in a |List| to the result of
-			expression {expr1}, which must be a list with the
+			the expression {expr1}, which must be a list with the
 			correct number of items.
 			{idx1} can be omitted, zero is used instead.
 			{idx2} can be omitted, meaning the end of the list.
 			When the selected range of items is partly past the
 			end of the list, items will be added.
 :let &g:{option-name} -= {expr1}
 			Like above, but only set the global value of an option
 			(if there is one).  Works like |:setglobal|.
 :let [{name1}, {name2}, ...] = {expr1}		*:let-unpack* *E687* *E688*
-			{expr1} must evaluate to a List.  The first item in
+			{expr1} must evaluate to a |List|.  The first item in
 			the list is assigned to {name1}, the second item to
 			{name2}, etc.
 			The number of names must match the number of items in
-			the List.
+			the |List|.
 			Each name can be one of the items of the ":let"
 			command as mentioned above.
 			Example: >
 				:let [s, item] = GetItem(s)
 <			Detail: {expr1} is evaluated first, then the
 :let [{name1}, {name2}, ...] .= {expr1}
 :let [{name1}, {name2}, ...] += {expr1}
 :let [{name1}, {name2}, ...] -= {expr1}
 			Like above, but append/add/subtract the value for each
-			List item.
+			|List| item.
 :let [{name}, ..., ; {lastname}] = {expr1}
-			Like |:let-unpack| above, but the List may have more
+			Like |:let-unpack| above, but the |List| may have more
 			items than there are names.  A list of the remaining
 			items is assigned to {lastname}.  If there are no
 			remaining items {lastname} is set to an empty list.
 			Example: >
 				:let [a, b; rest] = ["aval", "bval", 3, 4]
 <
 :let [{name}, ..., ; {lastname}] .= {expr1}
 :let [{name}, ..., ; {lastname}] += {expr1}
 :let [{name}, ..., ; {lastname}] -= {expr1}
 			Like above, but append/add/subtract the value for each
-			List item.
+			|List| item.
 							*E106*
 :let {var-name}	..	List the value of variable {var-name}.  Multiple
 			variable names may be given.  Special names recognized
 			here:				*E738*
 			  g:	global variables.
 :unl[et][!] {name} ...					*:unlet* *:unl* *E108*
 			Remove the internal variable {name}.  Several variable
 			names can be given, they are all removed.  The name
-			may also be a List or Dictionary item.
+			may also be a |List| or |Dictionary| item.
 			With [!] no error message is given for non-existing
 			variables.
-			One or more items from a List can be removed: >
+			One or more items from a |List| can be removed: >
 				:unlet list[3]	  " remove fourth item
 				:unlet list[3:]   " remove fourth item to last
-<			One item from a Dictionary can be removed at a time: >
+<			One item from a |Dictionary| can be removed at a time: >
 				:unlet dict['two']
 				:unlet dict.two
 :lockv[ar][!] [depth] {name} ...			*:lockvar* *:lockv*
 			Lock the internal variable {name}.  Locking means that
 				:unlet v
 <							*E741*
 			If you try to change a locked variable you get an
 			error message: "E741: Value of {name} is locked"
-			[depth] is relevant when locking a List or Dictionary.
+			[depth] is relevant when locking a |List| or
-			It specifies how deep the locking goes:
+			|Dictionary|.  It specifies how deep the locking goes:
-				1	Lock the List or Dictionary itself,
+				1	Lock the |List| or |Dictionary| itself,
 					cannot add or remove items, but can
 					still change their values.
 				2	Also lock the values, cannot change
-					the items.  If an item is a List or
+					the items.  If an item is a |List| or
-					Dictionary, cannot add or remove
+					|Dictionary|, cannot add or remove
 					items, but can still change the
 					values.
-				3	Like 2 but for the List/Dictionary in
+				3	Like 2 but for the |List| /
-					the List/Dictionary, one level deeper.
+					|Dictionary| in the |List| /
-			The default [depth] is 2, thus when {name} is a List
+					|Dictionary|, one level deeper.
-			or Dictionary the values cannot be changed.
+			The default [depth] is 2, thus when {name} is a |List|
+			or |Dictionary| the values cannot be changed.
 								*E743*
 			For unlimited depth use [!] and omit [depth].
 			However, there is a maximum depth of 100 to catch
 			loops.
-			Note that when two variables refer to the same List
+			Note that when two variables refer to the same |List|
-			and you lock one of them, the List will also be locked
+			and you lock one of them, the |List| will also be
-			when used through the other variable.  Example: >
+			locked when used through the other variable.  Example:
+			>
 				:let l = [0, 1, 2, 3]
 				:let cl = l
 				:lockvar l
 				:let cl[1] = 99		" won't work!
 <			You may want to make a copy of a list to avoid this.

Mercurial > vim

comparison runtime/doc/eval.txt @ 685:d7e33248b9c8 v7.0206