Lines Matching refs:expression
7 Expression evaluation *expression* *expr* *E15* *eval*
26 2. Expression syntax |expression-syntax|
31 7. Commands |expression-commands|
138 An expression can be used as a condition, ignoring the type and only using
184 function or created with the lambda expression |expr-lambda|. It can be used
185 in an expression in the place of a function name, before the parenthesis
267 An item can be any expression. Using a List for an item creates a
533 A value can be any expression. Using a Dictionary for a value creates a
811 If you need to know the type of a variable or expression, use the |type()|
832 2. Expression syntax *expression-syntax*
894 (expr1) nested expression
901 {args -> expr1} lambda expression
919 The expression before the '?' is evaluated to a number. If it evaluates to
920 |TRUE|, the result is the value of the expression between the '?' and ':',
921 otherwise the result is the value of the expression after the ':'.
925 Since the first expression is an "expr2", it cannot contain another ?:. The
945 The expression before the '??' is evaluated. If it evaluates to
946 |truthy|, this is used as the result. Otherwise the expression after the '??'
948 value for an expression that may result in zero or empty: >
982 Once the result is known, the expression "short-circuits", that is, further
1176 This expression is either |expr9| or a sequence of the alternatives below,
1489 When using the '=' register you get the expression itself, not what it
1495 (expr1) nested expression
1536 lambda expression *expr-lambda* *lambda*
1538 {args -> expr1} lambda expression
1540 A lambda expression creates a new unnamed function which returns the result of
1544 1. The body of the lambda expression is an |expr1| and not a sequence of |Ex|
1577 Examples for using a lambda expression with |sort()|, |map()| and |filter()|: >
1583 The lambda expression is also useful for Channel, Job and timer: >
1605 for a lambda expression, you can find what it is with the following command: >
2080 evaluating the expression used with |map()| and |filter()|.
2432 valid while evaluating the expression used with |map()| and
2788 luaeval({expr} [, {expr}]) any evaluate |Lua| expression
2824 mzeval({expr}) any evaluate |MzScheme| expression
2829 perleval({expr}) any evaluate |Perl| expression
2880 py3eval({expr}) any evaluate |python3| expression
2881 pyeval({expr}) any evaluate |Python| expression
2882 pyxeval({expr}) any evaluate |python_x| expression
2901 String send expression
2920 rubyeval({expr}) any evaluate |Ruby| expression
3865 or with an expression mapping.
4523 runtime. Use `exists_compiled()` to evaluate the expression
4552 expression. E.g.: >
4673 <cexpr> C expression under the cursor
4855 expression, which is used as a String.
4901 Note that {expr2} is the result of expression and is then
4902 used as an expression again. Often it is good to use a
5631 |c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
5646 |c_CTRL-\_e| or |c_CTRL-R_=| or an expression mapping.
5673 expression Vim expression
6189 getreg('=') returns the last evaluated value of the expression
6191 getreg('=', 1) returns the expression itself, so that it can
6647 "expr" or "=" typed expression history
6672 regular expression. All entries matching that expression will
6683 Clear expression register history: >
7075 is any expression, which is used as a String.
7198 - An empty JSON expression or made of only spaces is accepted
7549 Evaluate Lua expression {expr} and return its result converted
7587 Note that {expr2} is the result of an expression and is then
7588 used as an expression again. Often it is good to use a
7662 "expr" 1 for an expression mapping (|:map-<expr>|).
7981 {str} is treated as a literal string and regular expression
8280 Evaluate MzScheme expression {expr} and return its result
8361 Evaluate Perl expression {expr} in scalar context and return
8704 Evaluate Python expression {expr} and return its result
8722 Evaluate Python expression {expr} and return its result
8738 Evaluate Python expression {expr} and return its result
9038 expression and the result is returned after evaluation.
9255 Evaluate Ruby expression {expr} and return its result
9413 If the {skip} expression is given it is evaluated with the
9417 {skip} can be a string, which is evaluated as an expression, a
9640 {skip} expression is evaluated with the cursor positioned on
9682 having to double the backslashes. The skip expression only
9870 set after the command line is set to the expression. For
9871 |c_CTRL-R_=| it is set after evaluating the expression but
10186 set search and expression registers. Lists containing no
10503 < For a simple expression you can use a lambda: >
10736 same as when using a floating point number in an expression,
10738 E.g., "1e40" is accepted, while in an expression you need to
11056 Only for an expression in a |:substitute| command or
11062 Also see |sub-replace-expression|.
11113 an expression. See |sub-replace-expression|. Example: >
11412 Returns a |List| of tags matching the regular expression {expr}.
11448 search regular expression pattern.
12346 eval Compiled with expression evaluation support. Always
12752 specified at a call, the default expression is used to initialize it.
12764 call, not definition. Thus it is possible to use an expression which is
12768 You can pass |v:none| to use the default expression. Note that this means you
12770 expression.
12878 A function can also be called as part of evaluating an expression or when it
12980 When Vim encounters this, it evaluates the expression inside the braces, puts
12981 that in place of the expression, and re-interprets the whole as a variable
12999 However, the expression inside the braces must evaluate to a valid single
13019 7. Commands *expression-commands*
13026 expression {expr1}. The variable will get the type
13031 Set a list item to the result of the expression
13046 the expression {expr1}, which must be a list with the
13070 the expression {expr1}. The type is always String.
13083 Write the result of the expression {expr1} in register
13102 expression {expr1}. A String or Number value is
13625 < The '%' is an illegal character in an expression. >
13640 :echom[sg] {expr1} .. Echo the expression(s) as a true message, saving the
13656 :echoe[rr] {expr1} .. Echo the expression(s) as an error message, saving the
13678 < The expression is supposed to have a side effect,
13682 expression.
13689 command, since "|" is seen as part of the expression.
13884 < *throw-expression*
13885 You can also specify an expression argument. The expression is then evaluated
13891 command. Unless it is caught there, the expression evaluation is abandoned.
13915 Any other command that takes an expression as argument might also be
13916 abandoned by an (uncaught) exception during the expression evaluation. The
14252 E15: Invalid expression: novar
14720 E15: Invalid expression: novar
14798 :"get the part matching the whole expression
14895 When the |+eval| feature was disabled at compile time, none of the expression
14958 A few options contain an expression. When this expression is evaluated it may