vim: runtime/doc/eval.txt comparison

comparison runtime/doc/eval.txt @ 17612:e259d11e2900 v8.1.1803

patch 8.1.1803: all builtin functions are global commit https://github.com/vim/vim/commit/ac92e25a33c37ec5becbfffeccda136c73b761ac Author: Bram Moolenaar <Bram@vim.org> Date: Sat Aug 3 21:58:38 2019 +0200 patch 8.1.1803: all builtin functions are global Problem: All builtin functions are global. Solution: Add the method call operator ->. Implemented for a limited number of functions.

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 03 Aug 2019 22:00:07 +0200
parents	2704c4e3e20a
children	072efa9ca875

comparison

equal deleted inserted replaced

-:b9a3d542a042
+:e259d11e2900
 This expression is either |expr9| or a sequence of the alternatives below,
 in any order.  E.g., these are all possible:
 	expr9[expr1].name
 	expr9.name[expr1]
 	expr9(expr1, ...)[expr1].name
+	expr9->(expr1, ...)[expr1]
+Evaluation is always from left to right.
 expr8[expr1]		item of String or |List|	*expr-[]* *E111*
 							*E909* *subscript*
 If expr8 is a Number or String this results in a String that contains the
 expr8(expr1, ...)	|Funcref| function call
 When expr8 is a |Funcref| type variable, invoke the function it refers to.
+expr8->name([args])	method call			*method*
+For global methods this is the same as: >
+	name(expr8 [, args])
+There can also be methods specifically for the type of "expr8".
 							*expr9*
 number
 ------
 number			number constant			*expr-number*
 			:call add(mylist, "woodstock")
 <		Note that when {expr} is a |List| it is appended as a single
 		item.  Use |extend()| to concatenate |Lists|.
 		When {object} is a |Blob| then  {expr} must be a number.
 		Use |insert()| to add an item at another position.
+		Can also be used as a |method|: >
+			mylist->add(val1)->add(val2)
 and({expr}, {expr})					*and()*
 		Bitwise AND on the two arguments.  The arguments are converted
 		to a number.  A List, Dict or Float argument causes an error.
 		that the original |List| can be changed without changing the
 		copy, and vice versa.  But the items are identical, thus
 		changing an item changes the contents of both |Lists|.
 		A |Dictionary| is copied in a similar way as a |List|.
 		Also see |deepcopy()|.
+		Can also be used as a |method|: >
+			mylist->copy()
 cos({expr})						*cos()*
 		Return the cosine of {expr}, measured in radians, as a |Float|.
 		{expr} must evaluate to a |Float| or a |Number|.
 		Examples: >
 		When {ic} is given and it's |TRUE| then case is ignored.
 		When {comp} is a string then the number of not overlapping
 		occurrences of {expr} is returned. Zero is returned when
 		{expr} is an empty string.
+		Can also be used as a |method|: >
+			mylist->count(val)
 							*cscope_connection()*
 cscope_connection([{num} , {dbpath} [, {prepend}]])
 		Checks for the existence of a |cscope| connection.  If no
 		parameters are specified, then the function returns:
 		- A |Channel| is empty when it is closed.
 		- A |Blob| is empty when its length is zero.
 		For a long |List| this is much faster than comparing the
 		length with zero.
+		Can also be used as a |method|: >
+			mylist->empty()
 escape({string}, {chars})				*escape()*
 		Escape the characters in {chars} that occur in {string} with a
 		backslash.  Example: >
 			:echo escape('c:\program files\vim', ' \')
 		{expr2} remains unchanged.
 		When {expr1} is locked and {expr2} is not empty the operation
 		fails.
 		Returns {expr1}.
+		Can also be used as a |method|: >
+			mylist->extend(otherlist)
 feedkeys({string} [, {mode}])				*feedkeys()*
 		Characters in {string} are queued for processing as if they
 		come from a mapping or were typed by the user.
 		When an error is encountered while evaluating {expr2} no
 		further items in {expr1} are processed.  When {expr2} is a
 		Funcref errors inside a function are ignored, unless it was
 		defined with the "abort" flag.
+		Can also be used as a |method|: >
+			mylist->filter(expr2)
 finddir({name} [, {path} [, {count}]])				*finddir()*
 		Find directory {name} in {path}.  Supports both downwards and
 		upwards recursive directory searches.  See |file-searching|
 		for the syntax of {path}.
 get({list}, {idx} [, {default}])			*get()*
 		Get item {idx} from |List| {list}.  When this item is not
 		available return {default}.  Return zero when {default} is
 		omitted.
+		Can also be used as a |method|: >
+			mylist->get(idx)
 get({blob}, {idx} [, {default}])
 		Get byte {idx} from |Blob| {blob}.  When this byte is not
 		available return {default}.  Return -1 when {default} is
 		omitted.
 get({dict}, {key} [, {default}])
 			: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
 		item.  Use |extend()| to concatenate |Lists|.
+		Can also be used as a |method|: >
+			mylist->insert(item)
 invert({expr})						*invert()*
 		Bitwise invert.  The argument is converted to a number.  A
 		List, Dict or Float argument causes an error.  Example: >
 			:let bits = invert(bits)
 		Example: >
 			for [key, value] in items(mydict)
 			   echo key . ': ' . value
 			endfor
+<		Can also be used as a |method|: >
+			mydict->items()
 job_ functions are documented here: |job-functions-details|
 join({list} [, {sep}])					*join()*
 		add it there too: >
 			let lines = join(mylist, "\n") . "\n"
 <		String items are used as-is.  |Lists| and |Dictionaries| are
 		converted into a string like with |string()|.
 		The opposite function is |split()|.
+		Can also be used as a |method|: >
+			mylist->join()
 js_decode({string})					*js_decode()*
 		This is similar to |json_decode()| with these differences:
 		- Object key names do not have to be in quotes.
 		- Strings can be in single quotes.
 keys({dict})						*keys()*
 		Return a |List| with all the keys of {dict}.  The |List| is in
 		arbitrary order.  Also see |items()| and |values()|.
-							*len()* *E701*
+		Can also be used as a |method|: >
+			mydict->keys()
+<							*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
 		returned.
 		When {expr} is a |Blob| the number of bytes is returned.
 		When {expr} is a |Dictionary| the number of entries in the
 		|Dictionary| is returned.
 		Otherwise an error is given.
-						*libcall()* *E364* *E368*
+		Can also be used as a |method|: >
+			mylist->len()
+<						*libcall()* *E364* *E368*
 libcall({libname}, {funcname}, {argument})
 		Call function {funcname} in the run-time library {libname}
 		with single argument {argument}.
 		This is useful to call functions in a library that you
 		especially made to be used with Vim.  Since only one argument
 		When an error is encountered while evaluating {expr2} no
 		further items in {expr1} are processed.  When {expr2} is a
 		Funcref errors inside a function are ignored, unless it was
 		defined with the "abort" flag.
+		Can also be used as a |method|: >
+			mylist->map(expr2)
 maparg({name} [, {mode} [, {abbr} [, {dict}]]])			*maparg()*
 		When {dict} is omitted or zero: Return the rhs of mapping
 		{name} in mode {mode}.  The returned String has special
 		characters translated like in the output of the ":map" command
 		it returns the maximum of all values in the dictionary.
 		If {expr} is neither a list nor a dictionary, or one of the
 		items in {expr} cannot be used as a Number this results in
 		an error.  An empty |List| or |Dictionary| results in zero.
-							*min()*
+		Can also be used as a |method|: >
+			mylist->max()
+<							*min()*
 min({expr})	Return the minimum value of all items in {expr}.
 		{expr} can be a list or a dictionary.  For a dictionary,
 		it returns the minimum of all values in the dictionary.
 		If {expr} is neither a list nor a dictionary, or one of the
 		items in {expr} cannot be used as a Number this results in
 		an error.  An empty |List| or |Dictionary| results in zero.
-							*mkdir()* *E739*
+		Can also be used as a |method|: >
+			mylist->min()
+<							*mkdir()* *E739*
 mkdir({name} [, {path} [, {prot}]])
 		Create directory {name}.
 		If {path} is "p" then intermediate directories are created as
 		necessary.  Otherwise it must be "".
 			:echo "last item: " . remove(mylist, -1)
 			:call remove(mylist, 0, 9)
 <
 		Use |delete()| to remove a file.
+		Can also be used as a |method|: >
+			mylist->remove(idx)
 remove({blob}, {idx} [, {end}])
 		Without {end}: Remove the byte at {idx} from |Blob| {blob} and
 		return the byte.
 		With {end}: Remove bytes from {idx} to {end} (inclusive) and
 		return a |Blob| with these bytes.  When {idx} points to the same
 		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'].
+		Can also be used as a |method|: >
+			mylist->repeat(count)
 resolve({filename})					*resolve()* *E655*
 		On MS-Windows, when {filename} is a shortcut (a .lnk file),
 		returns the path the shortcut points to in a simplified form.
 		When {filename} is a symbolic link or junction point, return
 		The simplification step is done as by |simplify()|.
 		resolve() keeps a leading path component specifying the
 		current directory (provided the result is still a relative
 		path name) and also keeps a trailing path separator.
-							*reverse()*
-reverse({object})
+reverse({object})					*reverse()*
 		Reverse the order of items in {object} in-place.
 		{object} can be a |List| or a |Blob|.
 		Returns {object}.
 		If you want an object to remain unmodified make a copy first: >
 			:let revlist = reverse(copy(mylist))
+<		Can also be used as a |method|: >
+			mylist->reverse()
 round({expr})							*round()*
 		Round off {expr} to the nearest integral value and return it
 		as a |Float|.  If {expr} lies halfway between two integral
 		values, then use the larger one (away from zero).
 		The sort is stable, items which compare equal (as number or as
 		string) will keep their relative position. E.g., when sorting
 		on numbers, text strings will sort next to each other, in the
 		same order as they were originally.
-		Also see |uniq()|.
+		Can also be used as a |method|: >
+			mylist->sort()
+<		Also see |uniq()|.
 		Example: >
 			func MyCompare(i1, i2)
 			   return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
 			endfunc
 		When a List or Dictionary has a recursive reference it is
 		replaced by "[...]" or "{...}".  Using eval() on the result
 		will then fail.
-		Also see |strtrans()|.
+		Can also be used as a |method|: >
+			mylist->string()
+<		Also see |strtrans()|.
 							*strlen()*
 strlen({expr})	The result is a Number, which is the length of the String
 		{expr} in bytes.
 		If the argument is a Number it is first converted to a String.
 			:if type(myvar) == type(v:false)
 			:if type(myvar) == type(v:none)
 <		To check if the v:t_ variables exist use this: >
 			:if exists('v:t_number')
+<		Can also be used as a |method|: >
+			mylist->type()
 undofile({name})					*undofile()*
 		Return the name of the undo file that would be used for a file
 		with name {name} when writing.  This uses the 'undodir'
 		option, finding directories that exist.  It does not check if
 		the undo file exists.
 		to remain unmodified make a copy first: >
 			:let newlist = uniq(copy(mylist))
 <		The default compare function uses the string representation of
 		each item.  For the use of {func} and {dict} see |sort()|.
+		Can also be used as a |method|: >
+			mylist->uniq()
 values({dict})						*values()*
 		Return a |List| with all the values of {dict}.  The |List| is
 		in arbitrary order.  Also see |items()| and |keys()|.
+		Can also be used as a |method|: >
+			mydict->values()
 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

Mercurial > vim

comparison runtime/doc/eval.txt @ 17612:e259d11e2900 v8.1.1803