Lines Matching refs:expr
7 Expression evaluation *expression* *expr* *E15* *eval*
50 Number A 32 or 64 bit signed number. |expr-number|
59 |expr-string| Examples: "ab\txx\"--" 'x-z''a,c'
184 function or created with the lambda expression |expr-lambda|. It can be used
549 form can be used |expr-entry|: >
961 expr3 || expr3 .. logical OR *expr-barbar*
962 expr4 && expr4 .. logical AND *expr-&&*
1005 *expr-==* *expr-!=* *expr->* *expr->=*
1006 *expr-<* *expr-<=* *expr-=~* *expr-!~*
1007 *expr-==#* *expr-!=#* *expr->#* *expr->=#*
1008 *expr-<#* *expr-<=#* *expr-=~#* *expr-!~#*
1009 *expr-==?* *expr-!=?* *expr->?* *expr->=?*
1010 *expr-<?* *expr-<=?* *expr-=~?* *expr-!~?*
1011 *expr-is* *expr-isnot* *expr-is#* *expr-isnot#*
1012 *expr-is?* *expr-isnot?*
1103 expr6 + expr6 Number addition, |List| or |Blob| concatenation *expr-+*
1104 expr6 - expr6 Number subtraction *expr--*
1105 expr6 . expr6 String concatenation *expr-.*
1106 expr6 .. expr6 String concatenation *expr-..*
1115 expr7 * expr7 Number multiplication *expr-star*
1116 expr7 / expr7 Number division *expr-/*
1117 expr7 % expr7 Number modulo *expr-%*
1158 ! expr7 logical NOT *expr-!*
1159 - expr7 unary minus *expr-unary--*
1160 + expr7 unary plus *expr-unary-+*
1184 expr8[expr1] item of String or |List| *expr-[]* *E111*
1218 expr8[expr1a : expr1b] substring or sublist *expr-[:]*
1274 expr8.name entry in a |Dictionary| *expr-entry*
1337 number number constant *expr-number*
1401 string *string* *String* *expr-string* *E114*
1403 "string" string constant *expr-quote*
1452 'string' string constant *expr-'*
1465 option *expr-option* *E112* *E113*
1480 register *expr-register* *@r*
1493 nesting *expr-nesting* *E110*
1498 environment variable *expr-env*
1511 *expr-env-expand*
1524 internal variable *expr-variable*
1530 function call *expr-function* *E116* *E118* *E119* *E120*
1536 lambda expression *expr-lambda* *lambda*
1803 character when using <expr> in an abbreviation |:map-<expr>|.
2102 v:lnum Line number for the 'foldexpr' |fold-expr|, 'formatexpr' and
2235 |--remote-expr|.
2483 abs({expr}) Float or Number absolute value of {expr}
2484 acos({expr}) Float arc cosine of {expr}
2486 and({expr}, {expr}) Number bitwise AND
2488 appendbufline({expr}, {lnum}, {text})
2490 in buffer {expr}
2496 asin({expr}) Float arc sine of {expr}
2519 atan({expr}) Float arc tangent of {expr}
2522 balloon_show({expr}) none show {expr} inside the balloon
2538 byteidx({expr}, {nr}) Number byte index of {nr}'th char in {expr}
2539 byteidxcomp({expr}, {nr}) Number byte index of {nr}'th char in {expr}
2542 ceil({expr}) Float round {expr} up
2546 ch_evalexpr({handle}, {expr} [, {options}])
2547 any evaluate {expr} on JSON {handle}
2562 ch_sendexpr({handle}, {expr} [, {options}])
2563 any send {expr} over JSON {handle}
2564 ch_sendraw({handle}, {expr} [, {options}])
2565 any send {expr} over raw {handle}
2571 char2nr({expr} [, {utf8}]) Number ASCII/UTF-8 value of first char in {expr}
2573 charcol({expr}) Number column number of cursor or mark
2579 col({expr}) Number column byte index of cursor or mark
2581 complete_add({expr}) Number add completion match
2586 copy({expr}) any make a shallow copy of {expr}
2587 cos({expr}) Float cosine of {expr}
2588 cosh({expr}) Float hyperbolic cosine of {expr}
2589 count({comp}, {expr} [, {ic} [, {start}]])
2590 Number count how many {expr} are in {comp}
2597 deepcopy({expr} [, {noref}]) any make a full copy of {expr}
2608 echoraw({expr}) none output {expr} as-is
2609 empty({expr}) Number |TRUE| if {expr} is empty
2614 executable({expr}) Number 1 if executable {expr} exists
2616 exepath({expr}) String full path of the command {expr}
2617 exists({expr}) Number |TRUE| if {expr} exists
2618 exists_compiled({expr}) Number |TRUE| if {expr} exists at compile time
2619 exp({expr}) Float exponential of {expr}
2620 expand({expr} [, {nosuf} [, {list}]])
2621 any expand special keywords in {expr}
2622 expandcmd({expr}) String expand {expr} like with `:edit`
2640 float2nr({expr}) Number convert Float {expr} to a Number
2641 floor({expr}) Float round {expr} down
2666 getchar([expr]) Number or String
2669 getcharpos({expr}) List position of cursor, mark, etc.
2671 getcharstr([expr]) String get one character from the user
2698 getpos({expr}) List position of cursor, mark, etc.
2705 gettabinfo([{expr}]) List list of tab pages
2718 glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
2719 any expand file wildcards in {expr}
2720 glob2regpat({expr}) String convert a glob pat into a search pat
2721 globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]])
2722 String do glob({expr}) for all dirs in {path}
2739 iconv({expr}, {from}, {to}) String convert encoding of {expr}
2741 index({object}, {expr} [, {start} [, {ic}]])
2742 Number index in {object} where {expr} appears
2753 invert({expr}) Number bitwise invert
2755 isinf({expr}) Number determine if {expr} is infinity value
2757 islocked({expr}) Number |TRUE| if {expr} is locked
2758 isnan({expr}) Number |TRUE| if {expr} is NaN
2769 js_encode({expr}) String encode JS style JSON
2771 json_encode({expr}) String encode JSON
2773 len({expr}) Number the length of {expr}
2776 line({expr} [, {winid}]) Number line nr of cursor, last line or mark
2786 log({expr}) Float natural logarithm (base e) of {expr}
2787 log10({expr}) Float logarithm of Float {expr} to base 10
2788 luaeval({expr} [, {expr}]) any evaluate |Lua| expression
2789 map({expr1}, {expr2}) List/Dict change each item in {expr1} to {expr}
2798 match({expr}, {pat} [, {start} [, {count}]])
2799 Number position where {pat} matches in {expr}
2806 matchend({expr}, {pat} [, {start} [, {count}]])
2807 Number position where {pat} ends in {expr}
2812 matchlist({expr}, {pat} [, {start} [, {count}]])
2813 List match and submatches of {pat} in {expr}
2814 matchstr({expr}, {pat} [, {start} [, {count}]])
2815 String {count}'th match of {pat} in {expr}
2816 matchstrpos({expr}, {pat} [, {start} [, {count}]])
2817 List {count}'th match of {pat} in {expr}
2818 max({expr}) Number maximum value of items in {expr}
2820 min({expr}) Number minimum value of items in {expr}
2823 mode([expr]) String current editing mode
2824 mzeval({expr}) any evaluate |MzScheme| expression
2826 nr2char({expr} [, {utf8}]) String single char with ASCII/UTF-8 value {expr}
2827 or({expr}, {expr}) Number bitwise OR
2828 pathshorten({expr} [, {len}]) String shorten directory names in a path
2829 perleval({expr}) any evaluate |Perl| expression
2857 prompt_setcallback({buf}, {expr}) none set prompt callback function
2880 py3eval({expr}) any evaluate |python3| expression
2881 pyeval({expr}) any evaluate |Python| expression
2882 pyxeval({expr}) any evaluate |python_x| expression
2883 rand([{expr}]) Number get pseudo-random number
2884 range({expr} [, {max} [, {stride}]])
2885 List items from {expr} to {max}
2887 readdir({dir} [, {expr} [, {dict}]])
2888 List file names in {dir} selected by {expr}
2889 readdirex({dir} [, {expr} [, {dict}]])
2890 List file info in {dir} selected by {expr}
2916 repeat({expr}, {count}) String repeat {expr} {count} times
2919 round({expr}) Float round off {expr}
2920 rubyeval({expr}) any evaluate |Ruby| expression
2942 setbufline({expr}, {lnum}, {text})
2944 {expr}
2948 setcharpos({expr}, {list}) Number set the {expr} position to {list}
2960 setpos({expr}, {list}) Number set the {expr} position to {list}
2993 sin({expr}) Float sine of {expr}
2994 sinh({expr}) Float hyperbolic sine of {expr}
2995 slice({expr}, {start} [, {end}]) String, List or Blob
3009 split({expr} [, {pat} [, {keepempty}]])
3010 List make |List| from {pat} separated {expr}
3011 sqrt({expr}) Float square root of {expr}
3012 srand([{expr}]) List get seed for |rand()|
3014 str2float({expr} [, {quoted}]) Float convert String to Float
3015 str2list({expr} [, {utf8}]) List convert each character of {expr} to
3017 str2nr({expr} [, {base} [, {quoted}]])
3019 strcharlen({expr}) Number character length of the String {expr}
3023 strchars({expr} [, {skipcc}]) Number character count of the String {expr}
3024 strdisplaywidth({expr} [, {col}]) Number display length of the String {expr}
3029 string({expr}) String String representation of {expr} value
3030 strlen({expr}) Number length of the String {expr}
3038 strtrans({expr}) String translate string to make it printable
3039 strwidth({expr}) Number display cell length of the String {expr}
3042 substitute({expr}, {pat}, {sub}, {flags})
3043 String all {pat} in {expr} replaced with {sub}
3052 system({expr} [, {input}]) String output of shell command/filter {expr}
3053 systemlist({expr} [, {input}]) List output of shell command/filter {expr}
3058 taglist({expr} [, {filename}]) List list of tags matching {expr}
3059 tan({expr}) Float tangent of {expr}
3060 tanh({expr}) Float hyperbolic tangent of {expr}
3084 term_setapi({buf}, {expr}) none set |terminal-api| function name prefix
3103 test_ignore_error({expr}) none ignore a specific error
3113 test_override({expr}, {val}) none test with Vim internal overrides
3114 test_refcount({expr}) Number get the reference count of {expr}
3118 test_settime({expr}) none set current time for testing
3128 tolower({expr}) String the String {expr} switched to lowercase
3129 toupper({expr}) String the String {expr} switched to uppercase
3134 trunc({expr}) Float truncate Float {expr}
3135 type({expr}) Number type of value {expr}
3136 typename({expr}) String representation of the type of {expr}
3142 virtcol({expr}) Number screen column of cursor or mark
3143 visualmode([expr]) String last visual mode used
3150 win_gotoid({expr}) Number go to window with ID {expr}
3151 win_id2tabwin({expr}) List get tab and window nr from window ID
3152 win_id2win({expr}) Number get window nr from window ID
3162 winnr([{expr}]) Number number of current window
3170 xor({expr}, {expr}) Number bitwise XOR
3173 abs({expr}) *abs()*
3174 Return the absolute value of {expr}. When {expr} evaluates to
3175 a |Float| abs() returns a |Float|. When {expr} can be
3192 acos({expr}) *acos()*
3193 Return the arc cosine of {expr} measured in radians, as a
3195 {expr} must evaluate to a |Float| or a |Number| in the range
3209 add({object}, {expr}) *add()*
3210 Append the item {expr} to |List| or |Blob| {object}. Returns
3214 < Note that when {expr} is a |List| it is appended as a single
3216 When {object} is a |Blob| then {expr} must be a number.
3223 and({expr}, {expr}) *and()*
3316 asin({expr}) *asin()*
3317 Return the arc sine of {expr} measured in radians, as a |Float|
3319 {expr} must evaluate to a |Float| or a |Number| in the range
3337 atan({expr}) *atan()*
3338 Return the principal value of the arc tangent of {expr}, in
3340 {expr} must evaluate to a |Float| or a |Number|.
3372 balloon_show({expr}) *balloon_show()*
3373 Show {expr} inside the balloon. For the GUI {expr} is used as
3374 a string. For a terminal {expr} can be a list, which contains
3375 the lines of the balloon. If {expr} is not a list it will be
3377 If {expr} is an empty string any existing balloon is removed.
3622 byteidx({expr}, {nr}) *byteidx()*
3624 {expr}. Use zero for the first character, it then returns
3647 byteidxcomp({expr}, {nr}) *byteidxcomp()*
3675 ceil({expr}) *ceil()*
3677 {expr} as a |Float| (round up).
3678 {expr} must evaluate to a |Float| or a |Number|.
3736 charcol({expr}) *charcol()*
3738 position given with {expr} instead of the byte position.
3821 col({expr}) The result is a Number, which is the byte index of the column
3822 position given with {expr}. The accepted positions are:
3832 Additionally {expr} can be [lnum, col]: a |List| with the line
3895 complete_add({expr}) *complete_add()*
3896 Add {expr} to the list of matches. Only to be used by the
3901 See |complete-functions| for an explanation of {expr}. It is
4034 copy({expr}) Make a copy of {expr}. For Numbers and Strings this isn't
4035 different from using {expr} directly.
4036 When {expr} is a |List| a shallow copy is created. This means
4045 cos({expr}) *cos()*
4046 Return the cosine of {expr}, measured in radians, as a |Float|.
4047 {expr} must evaluate to a |Float| or a |Number|.
4060 cosh({expr}) *cosh()*
4061 Return the hyperbolic cosine of {expr} as a |Float| in the range
4063 {expr} must evaluate to a |Float| or a |Number|.
4076 count({comp}, {expr} [, {ic} [, {start}]]) *count()*
4077 Return the number of times an item with value {expr} appears
4086 occurrences of {expr} is returned. Zero is returned when
4087 {expr} is an empty string.
4178 deepcopy({expr} [, {noref}]) *deepcopy()* *E698*
4179 Make a copy of {expr}. For Numbers and Strings this isn't
4180 different from using {expr} directly.
4181 When {expr} is a |List| a full copy is created. This means
4395 empty({expr}) *empty()*
4396 Return the Number 1 if {expr} is empty, zero otherwise.
4447 executable({expr}) *executable()*
4448 This function checks if an executable with the name {expr}
4449 exists. {expr} must be the name of the program without any
4506 exepath({expr}) *exepath()*
4507 If {expr} is an executable and is either an absolute path, a
4509 Note that the current directory is used when {expr} starts
4512 < If {expr} cannot be found in $PATH or is not executable then
4519 exists({expr}) The result is a Number, which is |TRUE| if {expr} is defined,
4529 The {expr} argument is a string, which contains one of these:
4617 exists_compiled({expr}) *exists_compiled()*
4627 {expr} must be a literal string. *E1232*
4632 exp({expr}) *exp()*
4633 Return the exponential of {expr} as a |Float| in the range
4635 {expr} must evaluate to a |Float| or a |Number|.
4727 |expr-env-expand|.
4812 and "\..." notation |expr-quote|. For example,
4992 float2nr({expr}) *float2nr()*
4993 Convert {expr} to a Number by omitting the part after the
4995 {expr} must evaluate to a |Float| or a Number.
4996 When the value of {expr} is out of range for a |Number| the
5019 floor({expr}) *floor()*
5021 {expr} as a |Float| (round down).
5022 {expr} must evaluate to a |Float| or a |Number|.
5470 getchar([expr]) *getchar()*
5472 If [expr] is omitted, wait until a character is available.
5473 If [expr] is 0, only get a character when one is available.
5475 If [expr] is 1, only check if a character is available, it is
5479 Without [expr] and when [expr] is 0 a whole character or
5489 When [expr] is 0 and Esc is typed, there will be a short delay
5493 When [expr] is 1 only the first byte is returned. For a
5567 getcharpos({expr})
5568 Get the position for String {expr}. Same as |getpos()| but the
5599 :nnoremap <expr> ; getcharsearch().forward ? ';' : ','
5600 :nnoremap <expr> , getcharsearch().forward ? ',' : ';'
5604 getcharstr([expr]) *getcharstr()*
5607 If [expr] is omitted, wait until a character is available.
5608 If [expr] is 0 or false, only get a character when one is
5610 If [expr] is 1 or true, only check if a character is
5802 deleted. See also |expr-env|.
6052 getpos({expr}) Get the position for String {expr}. For possible values of
6053 {expr} see |line()|. For getting the cursor position see
6442 glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) *glob()*
6443 Expand the file wildcards in {expr}. See |wildcards| for the
6496 globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]])
6497 Perform glob() for String {expr} on all directories in {path}
6502 directory name is prepended to {expr} and expanded like with
6647 "expr" or "=" typed expression history
6684 :call histdel("expr")
6726 :let inp_index = histnr("expr")
6896 index({object}, {expr} [, {start} [, {ic}]]) *index()*
6898 has a value equal to {expr}. There is no automatic
6904 value is equal to {expr}.
6910 -1 is returned when {expr} is not found in {object}.
7064 invert({expr}) *invert()*
7080 isinf({expr}) *isinf()*
7081 Return 1 if {expr} is a positive infinity, or -1 a negative
7093 islocked({expr}) *islocked()* *E786*
7094 The result is a Number, which is |TRUE| when {expr} is the
7096 The string argument {expr} must be the name of a variable,
7104 < When {expr} is a variable that does not exist you get an error
7111 isnan({expr}) *isnan()*
7112 Return |TRUE| if {expr} is a float with value NaN. >
7161 js_encode({expr}) *js_encode()*
7214 json_encode({expr}) *json_encode()*
7215 Encode {expr} as JSON and return this as a string.
7250 len({expr}) The result is a Number, which is the length of the argument.
7251 When {expr} is a String or a Number the length in bytes is
7253 When {expr} is a |List| the number of items in the |List| is
7255 When {expr} is a |Blob| the number of bytes is returned.
7256 When {expr} is a |Dictionary| the number of entries in the
7329 line({expr} [, {winid}]) *line()*
7331 position given with {expr}. The {expr} argument is a string.
7518 log({expr}) *log()*
7519 Return the natural logarithm (base e) of {expr} as a |Float|.
7520 {expr} must evaluate to a |Float| or a |Number| in the range
7534 log10({expr}) *log10()*
7535 Return the logarithm of Float {expr} to base 10 as a |Float|.
7536 {expr} must evaluate to a |Float| or a |Number|.
7548 luaeval({expr} [, {expr}]) *luaeval()*
7549 Evaluate Lua expression {expr} and return its result converted
7550 to Vim data structures. Second {expr} may hold additional
7551 argument accessible as _A inside first {expr}.
7561 to {expr}.
7662 "expr" 1 for an expression mapping (|:map-<expr>|).
7748 match({expr}, {pat} [, {start} [, {count}]]) *match()*
7749 When {expr} is a |List| then this returns the index of the
7753 Otherwise, {expr} is used as a String. The result is a
7754 Number, which gives the index (byte offset) in {expr} where
7790 If {start} is out of range ({start} > strlen({expr}) for a
7791 String or {start} > len({expr}) for a |List|) -1 is returned.
7935 matchend({expr}, {pat} [, {start} [, {count}]]) *matchend()*
7952 When {expr} is a |List| the result is equal to |match()|.
8038 matchlist({expr}, {pat} [, {start} [, {count}]]) *matchlist()*
8053 matchstr({expr}, {pat} [, {start} [, {count}]]) *matchstr()*
8063 When {expr} is a |List| then the matching item is returned.
8069 matchstrpos({expr}, {pat} [, {start} [, {count}]]) *matchstrpos()*
8080 When {expr} is a |List| then the matching item, the index
8092 max({expr}) Return the maximum value of all items in {expr}. Example: >
8095 < {expr} can be a |List| or a |Dictionary|. For a Dictionary,
8097 If {expr} is neither a List nor a Dictionary, or one of the
8098 items in {expr} cannot be used as a Number this results in
8180 min({expr}) Return the minimum value of all items in {expr}. Example: >
8183 < {expr} can be a |List| or a |Dictionary|. For a Dictionary,
8185 If {expr} is neither a List nor a Dictionary, or one of the
8186 items in {expr} cannot be used as a Number this results in
8225 mode([expr]) Return a string that indicates the current mode.
8226 If [expr] is supplied and it evaluates to a non-zero Number or
8279 mzeval({expr}) *mzeval()*
8280 Evaluate MzScheme expression {expr} and return its result
8295 to {expr}.
8314 nr2char({expr} [, {utf8}]) *nr2char()*
8316 value {expr}. Examples: >
8335 or({expr}, {expr}) *or()*
8360 perleval({expr}) *perleval()*
8361 Evaluate Perl expression {expr} in scalar context and return
8364 Note: If you want an array or hash, {expr} must return a
8371 to {expr}.
8621 prompt_setcallback({buf}, {expr}) *prompt_setcallback()*
8622 Set prompt callback for buffer {buf} to {expr}. When {expr}
8655 prompt_setinterrupt({buf}, {expr}) *prompt_setinterrupt()*
8656 Set a callback for buffer {buf} to {expr}. When {expr} is an
8703 py3eval({expr}) *py3eval()*
8704 Evaluate Python expression {expr} and return its result
8713 to {expr}.
8721 pyeval({expr}) *pyeval()*
8722 Evaluate Python expression {expr} and return its result
8730 to {expr}.
8737 pyxeval({expr}) *pyxeval()*
8738 Evaluate Python expression {expr} and return its result
8749 rand([{expr}]) *rand()* *random*
8751 algorithm using seed {expr}. The returned number is 32 bits,
8753 {expr} can be initialized by |srand()| and will be updated by
8754 rand(). If {expr} is omitted, an internal seed value is used
8765 range({expr} [, {max} [, {stride}]]) *range()*
8767 - If only {expr} is specified: [0, 1, ..., {expr} - 1]
8768 - If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
8769 - If {stride} is specified: [{expr}, {expr} + {stride}, ...,
8770 {max}] (increasing {expr} with {stride} each time, not
8794 readdir({directory} [, {expr} [, {dict}]]) *readdir()*
8801 When {expr} is omitted all entries are included.
8802 When {expr} is given, it is evaluated to check what to do:
8803 If {expr} results in -1 then no further entries will
8805 If {expr} results in 0 then this entry will not be
8807 If {expr} results in 1 then this entry will be added
8810 Each time {expr} is evaluated |v:val| is set to the entry name.
8811 When {expr} is a function the name is passed as the argument.
8848 readdirex({directory} [, {expr} [, {dict}]]) *readdirex()*
8885 When {expr} is omitted all entries are included.
8886 When {expr} is given, it is evaluated to check what to do:
8887 If {expr} results in -1 then no further entries will
8889 If {expr} results in 0 then this entry will not be
8891 If {expr} results in 1 then this entry will be added
8894 Each time {expr} is evaluated |v:val| is set to a |Dictionary|
8896 When {expr} is a function the entry is passed as the argument.
9041 between (not at the end), like with join(expr, "\n").
9063 ServerName()->remote_expr(expr)
9195 repeat({expr}, {count}) *repeat()*
9196 Repeat {expr} {count} times and return the concatenated
9200 When {expr} is a |List| the result is {expr} concatenated
9236 round({expr}) *round()*
9237 Round off {expr} to the nearest integral value and return it
9238 as a |Float|. If {expr} lies halfway between two integral
9240 {expr} must evaluate to a |Float| or a |Number|.
9254 rubyeval({expr}) *rubyeval()*
9255 Evaluate Ruby expression {expr} and return its result
9264 to {expr}.
9312 nnoremap <expr> GG ":echom ".screencol()."\n"
9826 setcharpos({expr}, {list}) *setcharpos()*
9902 See also |expr-env|.
9992 setpos({expr}, {list})
9993 Set the position for String {expr}. Possible values:
10031 An error message is given if {expr} is invalid.
10388 sin({expr}) *sin()*
10389 Return the sine of {expr}, measured in radians, as a |Float|.
10390 {expr} must evaluate to a |Float| or a |Number|.
10403 sinh({expr}) *sinh()*
10404 Return the hyperbolic sine of {expr} as a |Float| in the range
10406 {expr} must evaluate to a |Float| or a |Number|.
10419 slice({expr}, {start} [, {end}]) *slice()*
10420 Similar to using a |slice| "expr[start : end]", but "end" is
10666 sqrt({expr}) *sqrt()*
10667 Return the non-negative square root of Float {expr} as a
10669 {expr} must evaluate to a |Float| or a |Number|. When {expr}
10684 srand([{expr}]) *srand()*
10686 - If {expr} is not given, seed values are initialized by
10689 - If {expr} is given it must be a Number. It is used to
10922 string({expr}) Return {expr} converted to a String. If {expr} is a Number,
10925 {expr} type result ~
11151 The result is the swap file path of the buffer {expr}.
11279 system({expr} [, {input}]) *system()* *E677*
11280 Get the output of the shell command {expr} as a |String|. See
11306 argument. Newlines in {expr} may cause the command to fail.
11322 'shell' 'shellcmdflag' 'shellxquote' {expr} 'shellredir' {tmp} 'shellxquote'
11324 For Unix, braces are put around {expr} to allow for
11343 systemlist({expr} [, {input}]) *systemlist()*
11411 taglist({expr} [, {filename}]) *taglist()*
11412 Returns a |List| of tags matching the regular expression {expr}.
11446 used in {expr}. This also make the function work faster.
11457 tan({expr}) *tan()*
11458 Return the tangent of {expr}, measured in radians, as a |Float|
11460 {expr} must evaluate to a |Float| or a |Number|.
11473 tanh({expr}) *tanh()*
11474 Return the hyperbolic tangent of {expr} as a |Float| in the
11476 {expr} must evaluate to a |Float| or a |Number|.
11638 tolower({expr}) *tolower()*
11646 toupper({expr}) *toupper()*
11701 trunc({expr}) *trunc()*
11703 equal to {expr} as a |Float| (truncate towards zero).
11704 {expr} must evaluate to a |Float| or a |Number|.
11719 type({expr}) The result is a Number representing the type of {expr}.
11749 typename({expr}) *typename()*
11750 Return a string representation of the type of {expr}.
11833 virtcol({expr}) *virtcol()*
11835 position given with {expr}. That is, the last screen position
11842 For the use of {expr} see |col()|.
11843 When 'virtualedit' is used {expr} can be [lnum, col, off], where
11874 visualmode([{expr}]) *visualmode()*
11888 If {expr} is supplied and it evaluates to a non-zero Number or
11899 :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
11966 win_gotoid({expr}) *win_gotoid()*
11967 Go to window with ID {expr}. This may also change the current
11974 win_id2tabwin({expr}) *win_id2tabwin()*
11976 with ID {expr}: [tabnr, winnr].
11982 win_id2win({expr}) *win_id2win()*
11983 Return the window number of window with ID {expr}.
12270 xor({expr}, {expr}) *xor()*
12712 :retu[rn] [expr] Return from a function. When "[expr]" is given, it is
12714 If "[expr]" is not given, the number 0 is returned.
12754 lambda expressions |expr-lambda|.
13027 from the {expr}. If {var-name} didn't exist yet, it
13675 :eval {expr} Evaluate {expr} and discard the result. Example: >
13713 < This has an <Esc> character, see |expr-string|.