Mercurial > vim
annotate runtime/doc/vim9.txt @ 31174:1d00fa720007 v9.0.0921
patch 9.0.0921: missing defined(PROTO) in #ifdef
Commit: https://github.com/vim/vim/commit/9af2ea80a874cecad9acd0a1c84e8e114182bbf8
Author: Bram Moolenaar <Bram@vim.org>
Date: Tue Nov 22 18:18:38 2022 +0000
patch 9.0.0921: missing defined(PROTO) in #ifdef
Problem: Missing defined(PROTO) in #ifdef.
Solution: Adjust #ifdef so that proto works with different features.
Clean up some preprocessor indenting.
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Tue, 22 Nov 2022 19:30:04 +0100 |
| parents | 20cf2080f1ee |
| children | a7801222c9c5 |
| rev | line source |
|---|---|
| 31139 | 1 *vim9.txt* For Vim version 9.0. Last change: 2022 Nov 14 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
3 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
4 VIM REFERENCE MANUAL by Bram Moolenaar |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
5 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
6 |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
7 Vim9 script commands and expressions. *Vim9* *vim9* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
8 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
9 Most expression help is in |eval.txt|. This file is about the new syntax and |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
10 features in Vim9 script. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
11 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
12 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
13 |
| 23466 | 14 1. What is Vim9 script? |Vim9-script| |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
15 2. Differences |vim9-differences| |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
16 3. New style functions |fast-functions| |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
17 4. Types |vim9-types| |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
18 5. Namespace, Import and Export |vim9script| |
| 22328 | 19 6. Future work: classes |vim9-classes| |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
20 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
21 9. Rationale |vim9-rationale| |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
22 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
23 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
24 |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
25 1. What is Vim9 script? *Vim9-script* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
26 |
| 20241 | 27 Vim script has been growing over time, while preserving backwards |
| 28 compatibility. That means bad choices from the past often can't be changed | |
| 20965 | 29 and compatibility with Vi restricts possible solutions. Execution is quite |
| 20241 | 30 slow, each line is parsed every time it is executed. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
31 |
| 20241 | 32 The main goal of Vim9 script is to drastically improve performance. This is |
| 33 accomplished by compiling commands into instructions that can be efficiently | |
| 34 executed. An increase in execution speed of 10 to 100 times can be expected. | |
| 35 | |
| 36 A secondary goal is to avoid Vim-specific constructs and get closer to | |
| 37 commonly used programming languages, such as JavaScript, TypeScript and Java. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
38 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
39 The performance improvements can only be achieved by not being 100% backwards |
| 29290 | 40 compatible. For example, making function arguments available in the "a:" |
| 41 dictionary adds quite a lot of overhead. In a Vim9 function this dictionary | |
| 42 is not available. Other differences are more subtle, such as how errors are | |
| 43 handled. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
44 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
45 The Vim9 script syntax and semantics are used in: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
46 - a function defined with the `:def` command |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
47 - a script file where the first command is `vim9script` |
| 22328 | 48 - an autocommand defined in the context of the above |
|
23938
2a885d095bff
patch 8.2.2511: Vim9: cannot use Vim9 script syntax in some places
Bram Moolenaar <Bram@vim.org>
parents:
23931
diff
changeset
|
49 - a command prefixed with the `vim9cmd` command modifier |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
50 |
| 23573 | 51 When using `:function` in a Vim9 script file the legacy syntax is used, with |
| 52 the highest |scriptversion|. However, this can be confusing and is therefore | |
| 53 discouraged. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
54 |
| 20241 | 55 Vim9 script and legacy Vim script can be mixed. There is no requirement to |
| 22328 | 56 rewrite old scripts, they keep working as before. You may want to use a few |
| 57 `:def` functions for code that needs to be fast. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
58 |
| 27537 | 59 :vim9[cmd] {cmd} *:vim9* *:vim9cmd* *E1164* |
|
27645
1712b102d642
patch 8.2.4348: "legacy exe cmd" does not do what one would expect
Bram Moolenaar <Bram@vim.org>
parents:
27634
diff
changeset
|
60 Evaluate and execute {cmd} using Vim9 script syntax and |
|
1712b102d642
patch 8.2.4348: "legacy exe cmd" does not do what one would expect
Bram Moolenaar <Bram@vim.org>
parents:
27634
diff
changeset
|
61 semantics. Useful when typing a command and in a legacy |
|
1712b102d642
patch 8.2.4348: "legacy exe cmd" does not do what one would expect
Bram Moolenaar <Bram@vim.org>
parents:
27634
diff
changeset
|
62 script or function. |
|
23938
2a885d095bff
patch 8.2.2511: Vim9: cannot use Vim9 script syntax in some places
Bram Moolenaar <Bram@vim.org>
parents:
23931
diff
changeset
|
63 |
| 27537 | 64 :leg[acy] {cmd} *:leg* *:legacy* *E1189* *E1234* |
|
27645
1712b102d642
patch 8.2.4348: "legacy exe cmd" does not do what one would expect
Bram Moolenaar <Bram@vim.org>
parents:
27634
diff
changeset
|
65 Evaluate and execute {cmd} using legacy script syntax and |
|
1712b102d642
patch 8.2.4348: "legacy exe cmd" does not do what one would expect
Bram Moolenaar <Bram@vim.org>
parents:
27634
diff
changeset
|
66 semantics. Only useful in a Vim9 script or a :def function. |
|
24531
3bfec39ce31c
patch 8.2.2805: Vim9: cannot use legacy syntax in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
24468
diff
changeset
|
67 Note that {cmd} cannot use local variables, since it is parsed |
|
3bfec39ce31c
patch 8.2.2805: Vim9: cannot use legacy syntax in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
24468
diff
changeset
|
68 with legacy expression syntax. |
|
3bfec39ce31c
patch 8.2.2805: Vim9: cannot use legacy syntax in Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
24468
diff
changeset
|
69 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
70 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
71 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
72 2. Differences from legacy Vim script *vim9-differences* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
73 |
| 22441 | 74 Overview ~ |
| 27537 | 75 *E1146* |
| 22441 | 76 Brief summary of the differences you will most often encounter when using Vim9 |
| 77 script and `:def` functions; details are below: | |
| 78 - Comments start with #, not ": > | |
| 23573 | 79 echo "hello" # comment |
| 22441 | 80 - Using a backslash for line continuation is hardly ever needed: > |
| 23573 | 81 echo "hello " |
| 22441 | 82 .. yourName |
| 83 .. ", how are you?" | |
|
26769
30972227ac8d
patch 8.2.3913: help for expressions does not mention Vim9 syntax
Bram Moolenaar <Bram@vim.org>
parents:
26755
diff
changeset
|
84 - White space is required in many places to improve readability. |
| 27459 | 85 - Assign values without `:let` *E1126* , declare variables with `:var`: > |
| 23573 | 86 var count = 0 |
| 22441 | 87 count += 3 |
| 88 - Constants can be declared with `:final` and `:const`: > | |
| 29104 | 89 final matches = [] # add to the list later |
| 22441 | 90 const names = ['Betty', 'Peter'] # cannot be changed |
| 91 - `:final` cannot be used as an abbreviation of `:finally`. | |
| 92 - Variables and functions are script-local by default. | |
| 93 - Functions are declared with argument types and return type: > | |
| 94 def CallMe(count: number, message: string): bool | |
| 95 - Call functions without `:call`: > | |
| 23573 | 96 writefile(['done'], 'file.txt') |
|
28002
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
97 - You cannot use old Ex commands: |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
98 `:Print` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
99 `:append` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
100 `:change` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
101 `:d` directly followed by 'd' or 'p'. |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
102 `:insert` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
103 `:k` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
104 `:mode` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
105 `:open` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
106 `:s` with only flags |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
107 `:t` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
108 `:xit` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
109 - Some commands, especially those used for flow control, cannot be shortened. |
| 30324 | 110 E.g., `:throw` cannot be written as `:th`. *vim9-no-shorten* |
| 25973 | 111 - You cannot use curly-braces names. |
| 22441 | 112 - A range before a command must be prefixed with a colon: > |
| 23573 | 113 :%s/this/that |
| 25700 | 114 - Executing a register with "@r" does not work, you can prepend a colon or use |
| 115 `:exe`: > | |
| 116 :exe @a | |
| 23573 | 117 - Unless mentioned specifically, the highest |scriptversion| is used. |
| 27162 | 118 - When defining an expression mapping, the expression will be evaluated in the |
| 119 context of the script where it was defined. | |
| 22441 | 120 |
| 121 | |
|
20023
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
122 Comments starting with # ~ |
|
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
123 |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
124 In legacy Vim script comments start with double quote. In Vim9 script |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
125 comments start with #. > |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
126 # declarations |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
127 var count = 0 # number of occurrences |
|
20023
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
128 |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
129 The reason is that a double quote can also be the start of a string. In many |
| 21825 | 130 places, especially halfway through an expression with a line break, it's hard |
| 131 to tell what the meaning is, since both a string and a comment can be followed | |
| 132 by arbitrary text. To avoid confusion only # comments are recognized. This | |
| 133 is the same as in shell scripts and Python programs. | |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
134 |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
135 In Vi # is a command to list text with numbers. In Vim9 script you can use |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
136 `:number` for that. > |
| 27036 | 137 :101 number |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
138 |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
139 To improve readability there must be a space between a command and the # |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
140 that starts a comment: > |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
141 var name = value # comment |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
142 var name = value# error! |
| 27537 | 143 < *E1170* |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
144 Do not start a comment with #{, it looks like the legacy dictionary literal |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
145 and produces an error where this might be confusing. #{{ or #{{{ are OK, |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
146 these can be used to start a fold. |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
147 |
| 29403 | 148 When starting to read a script file Vim doesn't know it is |Vim9| script until |
| 149 the `vim9script` command is found. Until that point you would need to use | |
| 150 legacy comments: > | |
| 151 " legacy comment | |
| 152 vim9script | |
| 153 # Vim9 comment | |
| 154 | |
| 155 That looks ugly, better put `vim9script` in the very first line: > | |
| 156 vim9script | |
| 157 # Vim9 comment | |
| 158 | |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
159 In legacy Vim script # is also used for the alternate file name. In Vim9 |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
160 script you need to use %% instead. Instead of ## use %%% (stands for all |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
161 arguments). |
| 20115 | 162 |
|
20023
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
163 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
164 Vim9 functions ~ |
| 27459 | 165 *E1099* |
| 20241 | 166 A function defined with `:def` is compiled. Execution is many times faster, |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
167 often 10 to 100 times. |
| 20241 | 168 |
| 20552 | 169 Many errors are already found when compiling, before the function is executed. |
| 20241 | 170 The syntax is strict, to enforce code that is easy to read and understand. |
| 171 | |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
172 Compilation is done when any of these is encountered: |
| 23164 | 173 - the first time the function is called |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
174 - when the `:defcompile` command is encountered in the script after the |
| 21991 | 175 function was defined |
| 176 - `:disassemble` is used for the function. | |
| 177 - a function that is compiled calls the function or uses it as a function | |
| 25700 | 178 reference (so that the argument and return types can be checked) |
| 27537 | 179 *E1091* *E1191* |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
180 If compilation fails it is not tried again on the next call, instead this |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
181 error is given: "E1091: Function is not compiled: {name}". |
| 24569 | 182 Compilation will fail when encountering a user command that has not been |
| 183 created yet. In this case you can call `execute()` to invoke it at runtime. > | |
| 184 def MyFunc() | |
| 185 execute('DefinedLater') | |
| 186 enddef | |
| 20552 | 187 |
| 188 `:def` has no options like `:function` does: "range", "abort", "dict" or | |
| 23164 | 189 "closure". A `:def` function always aborts on an error (unless `:silent!` was |
| 26708 | 190 used for the command or the error was caught a `:try` block), does not get a |
| 29104 | 191 range passed, cannot be a "dict" function, and can always be a closure. |
| 25700 | 192 *vim9-no-dict-function* |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
193 Later classes will be added, which replaces the "dict function" mechanism. |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
194 For now you will need to pass the dictionary explicitly: > |
| 29104 | 195 def DictFunc(self: dict<any>, arg: string) |
| 196 echo self[arg] | |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
197 enddef |
| 28246 | 198 var ad = {item: 'value', func: DictFunc} |
| 28379 | 199 ad.func(ad, 'item') |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
200 |
| 25836 | 201 You can call a legacy dict function though: > |
| 202 func Legacy() dict | |
| 203 echo self.value | |
| 204 endfunc | |
| 205 def CallLegacy() | |
| 206 var d = {func: Legacy, value: 'text'} | |
| 207 d.func() | |
| 208 enddef | |
| 27537 | 209 < *E1096* *E1174* *E1175* |
| 20241 | 210 The argument types and return type need to be specified. The "any" type can |
| 211 be used, type checking will then be done at runtime, like with legacy | |
| 212 functions. | |
| 27459 | 213 *E1106* |
| 21825 | 214 Arguments are accessed by name, without "a:", just like any other language. |
| 215 There is no "a:" dictionary or "a:000" list. | |
| 27537 | 216 *vim9-variable-arguments* *E1055* *E1160* *E1180* |
| 20241 | 217 Variable arguments are defined as the last argument, with a name and have a |
| 21825 | 218 list type, similar to TypeScript. For example, a list of numbers: > |
| 22171 | 219 def MyFunc(...itemlist: list<number>) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
220 for item in itemlist |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
221 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
222 |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
223 When a function argument is optional (it has a default value) passing `v:none` |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
224 as the argument results in using the default value. This is useful when you |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
225 want to specify a value for an argument that comes after an argument that |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
226 should use its default value. Example: > |
| 25973 | 227 def MyFunc(one = 'one', last = 'last') |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
228 ... |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
229 enddef |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
230 MyFunc(v:none, 'LAST') # first argument uses default value 'one' |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
231 < |
| 27537 | 232 *vim9-ignored-argument* *E1181* |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
233 The argument "_" (an underscore) can be used to ignore the argument. This is |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
234 most useful in callbacks where you don't need it, but do need to give an |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
235 argument to match the call. E.g. when using map() two arguments are passed, |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
236 the key and the value, to ignore the key: > |
| 29104 | 237 map(numberList, (_, v) => v * 2) |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
238 There is no error for using the "_" argument multiple times. No type needs to |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
239 be given. |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
240 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
241 |
| 20241 | 242 Functions and variables are script-local by default ~ |
| 20856 | 243 *vim9-scopes* |
| 20115 | 244 When using `:function` or `:def` to specify a new function at the script level |
|
27634
9fe2fed9bb4b
Update runtime files. (closes #9741)
Bram Moolenaar <Bram@vim.org>
parents:
27623
diff
changeset
|
245 in a Vim9 script, the function is local to the script. Like prefixing "s:" in |
|
9fe2fed9bb4b
Update runtime files. (closes #9741)
Bram Moolenaar <Bram@vim.org>
parents:
27623
diff
changeset
|
246 legacy script. To define a global function or variable the "g:" prefix must |
|
9fe2fed9bb4b
Update runtime files. (closes #9741)
Bram Moolenaar <Bram@vim.org>
parents:
27623
diff
changeset
|
247 be used. For functions in a script that is to be imported and in an autoload |
| 29104 | 248 script "export" needs to be used for those to be used elsewhere. > |
|
21550
b0b57d91671c
patch 8.2.1325: Vim9: using Vim9 script for autaload not tested
Bram Moolenaar <Bram@vim.org>
parents:
21516
diff
changeset
|
249 def ThisFunction() # script-local |
| 22171 | 250 def g:ThatFunction() # global |
| 27623 | 251 export def Function() # for import and import autoload |
| 27321 | 252 < *E1058* *E1075* |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
253 When using `:function` or `:def` to specify a nested function inside a `:def` |
| 26438 | 254 function and no namespace was given, this nested function is local to the code |
| 27903 | 255 block it is defined in. It cannot be used in `function()` with a string |
| 256 argument, pass the function reference itself: > | |
| 257 def Outer() | |
| 258 def Inner() | |
| 259 echo 'inner' | |
| 260 enddef | |
| 261 var Fok = function(Inner) # OK | |
| 262 var Fbad = function('Inner') # does not work | |
| 263 | |
| 29104 | 264 Detail: this is because "Inner" will actually become a function reference to a |
| 265 function with a generated name. | |
| 266 | |
| 267 It is not possible to define a script-local function in a function. You can | |
| 268 define a local function and assign it to a script-local funcref (it must have | |
| 269 been declared at the script level). It is possible to define a global | |
| 270 function by using the "g:" prefix. | |
| 20115 | 271 |
| 272 When referring to a function and no "s:" or "g:" prefix is used, Vim will | |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
273 search for the function: |
| 22565 | 274 - in the function scope, in block scopes |
| 29104 | 275 - in the script scope |
| 276 | |
| 277 Imported functions are found with the prefix from the `:import` command. | |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
278 |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
279 Since a script-local function reference can be used without "s:" the name must |
| 24278 | 280 start with an upper case letter even when using the "s:" prefix. In legacy |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
281 script "s:funcref" could be used, because it could not be referred to with |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
282 "funcref". In Vim9 script it can, therefore "s:Funcref" must be used to avoid |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
283 that the name interferes with builtin functions. |
| 29533 | 284 *vim9-s-namespace* *E1268* |
|
27634
9fe2fed9bb4b
Update runtime files. (closes #9741)
Bram Moolenaar <Bram@vim.org>
parents:
27623
diff
changeset
|
285 The use of the "s:" prefix is not supported at the Vim9 script level. All |
|
9fe2fed9bb4b
Update runtime files. (closes #9741)
Bram Moolenaar <Bram@vim.org>
parents:
27623
diff
changeset
|
286 functions and variables without a prefix are script-local. |
|
27843
532a0c5de1ec
patch 8.2.4447: Vim9: can still use s:var in a compiled function
Bram Moolenaar <Bram@vim.org>
parents:
27804
diff
changeset
|
287 |
|
532a0c5de1ec
patch 8.2.4447: Vim9: can still use s:var in a compiled function
Bram Moolenaar <Bram@vim.org>
parents:
27804
diff
changeset
|
288 In :def functions the use of "s:" depends on the script: Script-local |
|
532a0c5de1ec
patch 8.2.4447: Vim9: can still use s:var in a compiled function
Bram Moolenaar <Bram@vim.org>
parents:
27804
diff
changeset
|
289 variables and functions in a legacy script do use "s:", while in a Vim9 script |
|
532a0c5de1ec
patch 8.2.4447: Vim9: can still use s:var in a compiled function
Bram Moolenaar <Bram@vim.org>
parents:
27804
diff
changeset
|
290 they do not use "s:". This matches what you see in the rest of the file. |
|
532a0c5de1ec
patch 8.2.4447: Vim9: can still use s:var in a compiled function
Bram Moolenaar <Bram@vim.org>
parents:
27804
diff
changeset
|
291 |
|
27634
9fe2fed9bb4b
Update runtime files. (closes #9741)
Bram Moolenaar <Bram@vim.org>
parents:
27623
diff
changeset
|
292 In legacy functions the use of "s:" for script items is required, as before. |
| 29104 | 293 No matter if the script is Vim9 or legacy. |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
294 |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
295 In all cases the function must be defined before used. That is when it is |
| 22723 | 296 called, when `:defcompile` causes it to be compiled, or when code that calls |
| 297 it is being compiled (to figure out the return type). | |
| 20241 | 298 |
| 21676 | 299 The result is that functions and variables without a namespace can usually be |
| 20241 | 300 found in the script, either defined there or imported. Global functions and |
| 29104 | 301 variables could be defined anywhere (good luck finding out where! You can |
| 302 often see where it was last set using |:verbose|). | |
| 27459 | 303 *E1102* |
| 21825 | 304 Global functions can still be defined and deleted at nearly any time. In |
| 20317 | 305 Vim9 script script-local functions are defined once when the script is sourced |
| 29104 | 306 and cannot be deleted or replaced by itself (it can be by reloading the |
| 307 script). | |
| 20115 | 308 |
| 23305 | 309 When compiling a function and a function call is encountered for a function |
| 310 that is not (yet) defined, the |FuncUndefined| autocommand is not triggered. | |
| 311 You can use an autoload function if needed, or call a legacy function and have | |
| 312 |FuncUndefined| triggered there. | |
| 313 | |
| 20115 | 314 |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
315 Reloading a Vim9 script clears functions and variables by default ~ |
| 27537 | 316 *vim9-reload* *E1149* *E1150* |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
317 When loading a legacy Vim script a second time nothing is removed, the |
|
28862
82244cfc4694
Update runtime files, new color schemes
Bram Moolenaar <Bram@vim.org>
parents:
28777
diff
changeset
|
318 commands will replace existing variables and functions, create new ones, and |
|
82244cfc4694
Update runtime files, new color schemes
Bram Moolenaar <Bram@vim.org>
parents:
28777
diff
changeset
|
319 leave removed things hanging around. |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
320 |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
321 When loading a Vim9 script a second time all existing script-local functions |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
322 and variables are deleted, thus you start with a clean slate. This is useful |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
323 if you are developing a plugin and want to try a new version. If you renamed |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
324 something you don't have to worry about the old name still hanging around. |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
325 |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
326 If you do want to keep items, use: > |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
327 vim9script noclear |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
328 |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
329 You want to use this in scripts that use a `finish` command to bail out at |
| 27804 | 330 some point when loaded again. E.g. when a buffer local option is set to a |
| 331 function, the function does not need to be defined more than once: > | |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
332 vim9script noclear |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
333 setlocal completefunc=SomeFunc |
| 27804 | 334 if exists('*SomeFunc') |
| 27623 | 335 finish |
| 336 endif | |
| 27804 | 337 def SomeFunc() |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
338 .... |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
339 |
|
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
340 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
341 Variable declarations with :var, :final and :const ~ |
|
28002
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
342 *vim9-declaration* *:var* *E1079* |
| 27459 | 343 *E1017* *E1020* *E1054* *E1087* *E1108* *E1124* |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
344 Local variables need to be declared with `:var`. Local constants need to be |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
345 declared with `:final` or `:const`. We refer to both as "variables" in this |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
346 section. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
347 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
348 Variables can be local to a script, function or code block: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
349 vim9script |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
350 var script_var = 123 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
351 def SomeFunc() |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
352 var func_var = script_var |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
353 if cond |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
354 var block_var = func_var |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
355 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
356 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
357 The variables are only visible in the block where they are defined and nested |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
358 blocks. Once the block ends the variable is no longer accessible: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
359 if cond |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
360 var inner = 5 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
361 else |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
362 var inner = 0 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
363 endif |
| 22171 | 364 echo inner # Error! |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
365 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
366 The declaration must be done earlier: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
367 var inner: number |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
368 if cond |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
369 inner = 5 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
370 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
371 inner = 0 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
372 endif |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
373 echo inner |
| 29104 | 374 |
| 375 Although this is shorter and faster for simple values: > | |
| 376 var inner = 0 | |
| 377 if cond | |
| 378 inner = 5 | |
| 379 endif | |
| 380 echo inner | |
| 27459 | 381 < *E1025* *E1128* |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
382 To intentionally hide a variable from code that follows, a block can be |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
383 used: > |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
384 { |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
385 var temp = 'temp' |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
386 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
387 } |
| 22171 | 388 echo temp # Error! |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
389 |
| 25402 | 390 This is especially useful in a user command: > |
| 391 | |
| 392 command -range Rename { | |
| 25619 | 393 var save = @a |
| 394 @a = 'some expression' | |
| 395 echo 'do something with ' .. @a | |
| 396 @a = save | |
| 397 } | |
| 25402 | 398 |
| 399 And with autocommands: > | |
| 400 | |
| 401 au BufWritePre *.go { | |
| 25619 | 402 var save = winsaveview() |
| 403 silent! exe ':%! some formatting command' | |
| 404 winrestview(save) | |
| 405 } | |
| 25402 | 406 |
| 407 Although using a :def function probably works better. | |
| 28246 | 408 |
| 27537 | 409 *E1022* *E1103* *E1130* *E1131* *E1133* |
|
28405
473cfd79bcd8
patch 8.2.4727: unused code
Bram Moolenaar <Bram@vim.org>
parents:
28379
diff
changeset
|
410 *E1134* |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
411 Declaring a variable with a type but without an initializer will initialize to |
|
26755
ddaea8dcaff5
patch 8.2.3906: Vim9 help still contains "under development" warnings
Bram Moolenaar <Bram@vim.org>
parents:
26745
diff
changeset
|
412 false (for bool), empty (for string, list, dict, etc.) or zero (for number, |
|
ddaea8dcaff5
patch 8.2.3906: Vim9 help still contains "under development" warnings
Bram Moolenaar <Bram@vim.org>
parents:
26745
diff
changeset
|
413 any, etc.). This matters especially when using the "any" type, the value will |
| 28246 | 414 default to the number zero. For example, when declaring a list, items can be |
| 415 added: > | |
| 416 var myList: list<number> | |
| 417 myList->add(7) | |
| 418 | |
| 419 Initializing a variable to a null value, e.g. `null_list`, differs from not | |
| 420 initializing the variable. This throws an error: > | |
| 421 var myList = null_list | |
| 422 myList->add(7) # E1130: Cannot add to null list | |
| 423 | |
| 424 < *E1016* *E1052* *E1066* | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
425 In Vim9 script `:let` cannot be used. An existing variable is assigned to |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
426 without any command. The same for global, window, tab, buffer and Vim |
|
26769
30972227ac8d
patch 8.2.3913: help for expressions does not mention Vim9 syntax
Bram Moolenaar <Bram@vim.org>
parents:
26755
diff
changeset
|
427 variables, because they are not really declared. Those can also be deleted |
|
21584
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
428 with `:unlet`. |
|
28002
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
429 *E1065* |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
430 You cannot use `:va` to declare a variable, it must be written with the full |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
431 name `:var`. Just to make sure it is easy to read. |
| 27537 | 432 *E1178* |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
433 `:lockvar` does not work on local variables. Use `:const` and `:final` |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
434 instead. |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
435 |
| 25619 | 436 The `exists()` and `exists_compiled()` functions do not work on local variables |
| 437 or arguments. | |
| 27537 | 438 *E1006* *E1041* *E1167* *E1168* *E1213* |
| 24024 | 439 Variables, functions and function arguments cannot shadow previously defined |
| 440 or imported variables and functions in the same script file. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
441 Variables may shadow Ex commands, rename the variable if needed. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
442 |
| 24387 | 443 Global variables must be prefixed with "g:", also at the script level. > |
| 19968 | 444 vim9script |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
445 var script_local = 'text' |
| 21499 | 446 g:global = 'value' |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
447 var Funcref = g:ThatFunction |
| 19968 | 448 |
| 27492 | 449 Global functions must be prefixed with "g:": > |
| 24387 | 450 vim9script |
| 451 def g:GlobalFunc(): string | |
| 452 return 'text' | |
| 453 enddef | |
| 27492 | 454 echo g:GlobalFunc() |
| 24387 | 455 The "g:" prefix is not needed for auto-load functions. |
| 456 | |
| 25619 | 457 *vim9-function-defined-later* |
| 458 Although global functions can be called without the "g:" prefix, they must | |
| 459 exist when compiled. By adding the "g:" prefix the function can be defined | |
| 460 later. Example: > | |
| 461 def CallPluginFunc() | |
| 462 if exists('g:loaded_plugin') | |
| 463 g:PluginFunc() | |
| 464 endif | |
| 465 enddef | |
| 466 | |
|
26873
be85735650f7
patch 8.2.3965: Vim9: no easy way to check if Vim9 script is supported
Bram Moolenaar <Bram@vim.org>
parents:
26769
diff
changeset
|
467 If you do it like this, you get an error at compile time that "PluginFunc" |
|
be85735650f7
patch 8.2.3965: Vim9: no easy way to check if Vim9 script is supported
Bram Moolenaar <Bram@vim.org>
parents:
26769
diff
changeset
|
468 does not exist, even when "g:loaded_plugin" does not exist: > |
| 25619 | 469 def CallPluginFunc() |
| 470 if exists('g:loaded_plugin') | |
| 471 PluginFunc() # Error - function not found | |
| 472 endif | |
| 473 enddef | |
| 474 | |
| 475 You can use exists_compiled() to avoid the error, but then the function would | |
| 476 not be called, even when "g:loaded_plugin" is defined later: > | |
| 477 def CallPluginFunc() | |
| 478 if exists_compiled('g:loaded_plugin') | |
| 479 PluginFunc() # Function may never be called | |
| 480 endif | |
| 481 enddef | |
| 482 | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
483 Since `&opt = value` is now assigning a value to option "opt", ":&" cannot be |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
484 used to repeat a `:substitute` command. |
| 24468 | 485 *vim9-unpack-ignore* |
|
24426
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
486 For an unpack assignment the underscore can be used to ignore a list item, |
|
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
487 similar to how a function argument can be ignored: > |
|
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
488 [a, _, c] = theList |
| 24468 | 489 To ignore any remaining items: > |
|
24426
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
490 [a, b; _] = longList |
| 27804 | 491 < *E1163* *E1080* |
|
24426
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
492 Declaring more than one variable at a time, using the unpack notation, is |
|
26346
8be6413a8e27
patch 8.2.3704: Vim9: cannot use a list declaration in a :def function
Bram Moolenaar <Bram@vim.org>
parents:
26304
diff
changeset
|
493 possible. Each variable can have a type or infer it from the value: > |
|
8be6413a8e27
patch 8.2.3704: Vim9: cannot use a list declaration in a :def function
Bram Moolenaar <Bram@vim.org>
parents:
26304
diff
changeset
|
494 var [v1: number, v2] = GetValues() |
|
8be6413a8e27
patch 8.2.3704: Vim9: cannot use a list declaration in a :def function
Bram Moolenaar <Bram@vim.org>
parents:
26304
diff
changeset
|
495 Use this only when there is a list with values, declaring one variable per |
|
8be6413a8e27
patch 8.2.3704: Vim9: cannot use a list declaration in a :def function
Bram Moolenaar <Bram@vim.org>
parents:
26304
diff
changeset
|
496 line is much easier to read and change later. |
|
24426
78343859f42d
patch 8.2.2753: Vim9: cannot ignore an item in assignment unpack
Bram Moolenaar <Bram@vim.org>
parents:
24408
diff
changeset
|
497 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
498 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
499 Constants ~ |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
500 *vim9-const* *vim9-final* |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
501 How constants work varies between languages. Some consider a variable that |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
502 can't be assigned another value a constant. JavaScript is an example. Others |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
503 also make the value immutable, thus when a constant uses a list, the list |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
504 cannot be changed. In Vim9 we can use both. |
| 30634 | 505 *E1021* *E1307* |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
506 `:const` is used for making both the variable and the value a constant. Use |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
507 this for composite structures that you want to make sure will not be modified. |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
508 Example: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
509 const myList = [1, 2] |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
510 myList = [3, 4] # Error! |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
511 myList[0] = 9 # Error! |
| 24024 | 512 myList->add(3) # Error! |
| 27459 | 513 < *:final* *E1125* |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
514 `:final` is used for making only the variable a constant, the value can be |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
515 changed. This is well known from Java. Example: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
516 final myList = [1, 2] |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
517 myList = [3, 4] # Error! |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
518 myList[0] = 9 # OK |
| 24024 | 519 myList->add(3) # OK |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
520 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
521 It is common to write constants as ALL_CAPS, but you don't have to. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
522 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
523 The constant only applies to the value itself, not what it refers to. > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
524 final females = ["Mary"] |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
525 const NAMES = [["John", "Peter"], females] |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
526 NAMES[0] = ["Jack"] # Error! |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
527 NAMES[0][0] = "Jack" # Error! |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
528 NAMES[1] = ["Emma"] # Error! |
| 23573 | 529 NAMES[1][0] = "Emma" # OK, now females[0] == "Emma" |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
530 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
531 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
532 Omitting :call and :eval ~ |
| 27537 | 533 *E1190* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
534 Functions can be called without `:call`: > |
| 22171 | 535 writefile(lines, 'file') |
| 19303 | 536 Using `:call` is still possible, but this is discouraged. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
537 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
538 A method call without `eval` is possible, so long as the start is an |
|
24128
fcbb1d4df15b
patch 8.2.2605: Vim9: string index and slice does not include composing chars
Bram Moolenaar <Bram@vim.org>
parents:
24103
diff
changeset
|
539 identifier or can't be an Ex command. For a function either "(" or "->" must |
|
fcbb1d4df15b
patch 8.2.2605: Vim9: string index and slice does not include composing chars
Bram Moolenaar <Bram@vim.org>
parents:
24103
diff
changeset
|
540 be following, without a line break. Examples: > |
|
21516
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
541 myList->add(123) |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
542 g:myList->add(123) |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
543 [1, 2, 3]->Process() |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
544 {a: 1, b: 2}->Process() |
|
21516
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
545 "foobar"->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
546 ("foobar")->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
547 'foobar'->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
548 ('foobar')->Process() |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
549 |
| 21825 | 550 In the rare case there is ambiguity between a function name and an Ex command, |
| 21676 | 551 prepend ":" to make clear you want to use the Ex command. For example, there |
| 552 is both the `:substitute` command and the `substitute()` function. When the | |
| 553 line starts with `substitute(` this will use the function. Prepend a colon to | |
| 554 use the command instead: > | |
|
19481
c27837cbe922
patch 8.2.0298: Vim9 script: cannot start command with a string constant
Bram Moolenaar <Bram@vim.org>
parents:
19473
diff
changeset
|
555 :substitute(pattern (replacement ( |
|
19473
b09afbebffee
patch 8.2.0294: cannot use Ex command that is also a function name
Bram Moolenaar <Bram@vim.org>
parents:
19404
diff
changeset
|
556 |
| 25402 | 557 If the expression starts with "!" this is interpreted as a shell command, not |
| 558 negation of a condition. Thus this is a shell command: > | |
| 559 !shellCommand->something | |
| 25700 | 560 Put the expression in parentheses to use the "!" for negation: > |
| 25402 | 561 (!expression)->Method() |
| 562 | |
|
19556
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
563 Note that while variables need to be defined before they can be used, |
| 21825 | 564 functions can be called before being defined. This is required to allow |
| 565 for cyclic dependencies between functions. It is slightly less efficient, | |
|
19556
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
566 since the function has to be looked up by name. And a typo in the function |
|
21516
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
567 name will only be found when the function is called. |
|
19556
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
568 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
569 |
| 19968 | 570 Omitting function() ~ |
| 571 | |
| 572 A user defined function can be used as a function reference in an expression | |
| 573 without `function()`. The argument types and return type will then be checked. | |
| 574 The function must already have been defined. > | |
| 575 | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
576 var Funcref = MyFunction |
| 19968 | 577 |
| 578 When using `function()` the resulting type is "func", a function with any | |
| 25161 | 579 number of arguments and any return type (including void). The function can be |
| 26708 | 580 defined later if the argument is in quotes. |
| 19968 | 581 |
| 582 | |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
583 Lambda using => instead of -> ~ |
| 24387 | 584 *vim9-lambda* |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
585 In legacy script there can be confusion between using "->" for a method call |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
586 and for a lambda. Also, when a "{" is found the parser needs to figure out if |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
587 it is the start of a lambda or a dictionary, which is now more complicated |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
588 because of the use of argument types. |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
589 |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
590 To avoid these problems Vim9 script uses a different syntax for a lambda, |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
591 which is similar to JavaScript: > |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
592 var Lambda = (arg) => expression |
| 27537 | 593 var Lambda = (arg): type => expression |
| 594 < *E1157* | |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
595 No line break is allowed in the arguments of a lambda up to and including the |
| 25056 | 596 "=>" (so that Vim can tell the difference between an expression in parentheses |
| 24911 | 597 and lambda arguments). This is OK: > |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
598 filter(list, (k, v) => |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
599 v > 0) |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
600 This does not work: > |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
601 filter(list, (k, v) |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
602 => v > 0) |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
603 This also does not work: > |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
604 filter(list, (k, |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
605 v) => v > 0) |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
606 But you can use a backslash to concatenate the lines before parsing: > |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
607 filter(list, (k, |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
608 \ v) |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
609 \ => v > 0) |
| 27537 | 610 < *vim9-lambda-arguments* *E1172* |
|
24408
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
611 In legacy script a lambda could be called with any number of extra arguments, |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
612 there was no way to warn for not using them. In Vim9 script the number of |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
613 arguments must match. If you do want to accept any arguments, or any further |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
614 arguments, use "..._", which makes the function accept |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
615 |vim9-variable-arguments|. Example: > |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
616 var Callback = (..._) => 'anything' |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
617 echo Callback(1, 2, 3) # displays "anything" |
|
96e0b898d5b4
patch 8.2.2744: Vim9: no way to explicitly ignore an argument
Bram Moolenaar <Bram@vim.org>
parents:
24387
diff
changeset
|
618 |
| 27537 | 619 < *inline-function* *E1171* |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
620 Additionally, a lambda can contain statements in {}: > |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
621 var Lambda = (arg) => { |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
622 g:was_called = 'yes' |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
623 return expression |
|
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
624 } |
| 24387 | 625 This can be useful for a timer, for example: > |
| 626 var count = 0 | |
| 627 var timer = timer_start(500, (_) => { | |
| 628 count += 1 | |
| 629 echom 'Handler called ' .. count | |
| 630 }, {repeat: 3}) | |
| 631 | |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
632 The ending "}" must be at the start of a line. It can be followed by other |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
633 characters, e.g.: > |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
634 var d = mapnew(dict, (k, v): string => { |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
635 return 'value' |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
636 }) |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
637 No command can follow the "{", only a comment can be used there. |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
638 |
| 27321 | 639 *command-block* *E1026* |
|
26612
2586659245db
patch 8.2.3835: the inline-function example does not work
Bram Moolenaar <Bram@vim.org>
parents:
26591
diff
changeset
|
640 The block can also be used for defining a user command. Inside the block Vim9 |
|
2586659245db
patch 8.2.3835: the inline-function example does not work
Bram Moolenaar <Bram@vim.org>
parents:
26591
diff
changeset
|
641 syntax will be used. |
|
2586659245db
patch 8.2.3835: the inline-function example does not work
Bram Moolenaar <Bram@vim.org>
parents:
26591
diff
changeset
|
642 |
| 26591 | 643 If the statements include a dictionary, its closing bracket must not be |
| 644 written at the start of a line. Otherwise, it would be parsed as the end of | |
| 645 the block. This does not work: > | |
| 646 command NewCommand { | |
|
26612
2586659245db
patch 8.2.3835: the inline-function example does not work
Bram Moolenaar <Bram@vim.org>
parents:
26591
diff
changeset
|
647 g:mydict = { |
| 26591 | 648 'key': 'value', |
| 649 } # ERROR: will be recognized as the end of the block | |
| 650 } | |
| 651 Put the '}' after the last item to avoid this: > | |
| 652 command NewCommand { | |
|
26612
2586659245db
patch 8.2.3835: the inline-function example does not work
Bram Moolenaar <Bram@vim.org>
parents:
26591
diff
changeset
|
653 g:mydict = { |
| 26591 | 654 'key': 'value' } |
| 655 } | |
| 656 | |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
657 Rationale: The "}" cannot be after a command because it would require parsing |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
658 the commands to find it. For consistency with that no command can follow the |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
659 "{". Unfortunately this means using "() => { command }" does not work, line |
|
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
660 breaks are always required. |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
661 |
| 23737 | 662 *vim9-curly* |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
663 To avoid the "{" of a dictionary literal to be recognized as a statement block |
| 24024 | 664 wrap it in parentheses: > |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
665 var Lambda = (arg) => ({key: 42}) |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
666 |
| 23737 | 667 Also when confused with the start of a command block: > |
| 668 ({ | |
| 669 key: value | |
| 670 })->method() | |
| 671 | |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
672 |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
673 Automatic line continuation ~ |
| 27459 | 674 *vim9-line-continuation* *E1097* |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
675 In many cases it is obvious that an expression continues on the next line. In |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
676 those cases there is no need to prefix the line with a backslash (see |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
677 |line-continuation|). For example, when a list spans multiple lines: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
678 var mylist = [ |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
679 'one', |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
680 'two', |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
681 ] |
|
20011
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
682 And when a dict spans multiple lines: > |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
683 var mydict = { |
|
20011
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
684 one: 1, |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
685 two: 2, |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
686 } |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
687 With a function call: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
688 var result = Func( |
|
20011
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
689 arg1, |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
690 arg2 |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
691 ) |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
692 |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
693 For binary operators in expressions not in [], {} or () a line break is |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
694 possible just before or after the operator. For example: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
695 var text = lead |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
696 .. middle |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
697 .. end |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
698 var total = start + |
| 23573 | 699 end - |
|
20013
bf377a9ffccb
patch 8.2.0562: Vim9: cannot split an expression into multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
20011
diff
changeset
|
700 correction |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
701 var result = positive |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
702 ? PosFunc(arg) |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
703 : NegFunc(arg) |
|
20013
bf377a9ffccb
patch 8.2.0562: Vim9: cannot split an expression into multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
20011
diff
changeset
|
704 |
| 21499 | 705 For a method call using "->" and a member using a dot, a line break is allowed |
| 706 before it: > | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
707 var result = GetBuilder() |
| 20965 | 708 ->BuilderSetWidth(333) |
| 709 ->BuilderSetHeight(777) | |
| 710 ->BuilderBuild() | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
711 var result = MyDict |
| 21499 | 712 .member |
| 20965 | 713 |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
714 For commands that have an argument that is a list of commands, the | character |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
715 at the start of the line indicates line continuation: > |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
716 autocmd BufNewFile *.match if condition |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
717 | echo 'match' |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
718 | endif |
|
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
719 |
| 25973 | 720 Note that this means that in heredoc the first line cannot start with a bar: > |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
721 var lines =<< trim END |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
722 | this doesn't work |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
723 END |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
724 Either use an empty line at the start or do not use heredoc. Or temporarily |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
725 add the "C" flag to 'cpoptions': > |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
726 set cpo+=C |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
727 var lines =<< trim END |
| 25973 | 728 | this works |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
729 END |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
730 set cpo-=C |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
731 If the heredoc is inside a function 'cpoptions' must be set before :def and |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
732 restored after the :enddef. |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
733 |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
734 In places where line continuation with a backslash is still needed, such as |
| 25161 | 735 splitting up a long Ex command, comments can start with '#\ ': > |
| 736 syn region Text | |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
737 \ start='foo' |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
738 #\ comment |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
739 \ end='bar' |
| 25161 | 740 Like with legacy script '"\ ' is used. This is also needed when line |
| 741 continuation is used without a backslash and a line starts with a bar: > | |
| 742 au CursorHold * echom 'BEFORE bar' | |
| 743 #\ some comment | |
| 744 | echom 'AFTER bar' | |
| 745 < | |
| 746 *E1050* | |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
747 To make it possible for the operator at the start of the line to be |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
748 recognized, it is required to put a colon before a range. This example will |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
749 add "start" and print: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
750 var result = start |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
751 + print |
| 21250 | 752 Like this: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
753 var result = start + print |
| 21250 | 754 |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
755 This will assign "start" and print a line: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
756 var result = start |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
757 :+ print |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
758 |
| 27321 | 759 After the range an Ex command must follow. Without the colon you can call a |
| 760 function without `:call`, but after a range you do need it: > | |
| 761 MyFunc() | |
| 762 :% call MyFunc() | |
| 763 | |
| 23047 | 764 Note that the colon is not required for the |+cmd| argument: > |
| 765 edit +6 fname | |
| 766 | |
|
20015
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
767 It is also possible to split a function header over multiple lines, in between |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
768 arguments: > |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
769 def MyFunc( |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
770 text: string, |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
771 separator = '-' |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
772 ): string |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
773 |
| 23305 | 774 Since a continuation line cannot be easily recognized the parsing of commands |
|
23318
c76240efdf02
patch 8.2.2204: Vim9: using -> both for method and lambda is confusing
Bram Moolenaar <Bram@vim.org>
parents:
23305
diff
changeset
|
775 has been made stricter. E.g., because of the error in the first line, the |
| 23305 | 776 second line is seen as a separate command: > |
| 777 popup_create(some invalid expression, { | |
| 778 exit_cb: Func}) | |
| 779 Now "exit_cb: Func})" is actually a valid command: save any changes to the | |
| 780 file "_cb: Func})" and exit. To avoid this kind of mistake in Vim9 script | |
| 781 there must be white space between most command names and the argument. | |
| 27459 | 782 *E1144* |
| 23305 | 783 |
| 23666 | 784 However, the argument of a command that is a command won't be recognized. For |
| 785 example, after "windo echo expr" a line break inside "expr" will not be seen. | |
| 786 | |
| 23305 | 787 |
| 21250 | 788 Notes: |
| 789 - "enddef" cannot be used at the start of a continuation line, it ends the | |
| 790 current function. | |
| 791 - No line break is allowed in the LHS of an assignment. Specifically when | |
| 792 unpacking a list |:let-unpack|. This is OK: > | |
| 22171 | 793 [var1, var2] = |
| 21250 | 794 Func() |
| 795 < This does not work: > | |
| 22171 | 796 [var1, |
| 21250 | 797 var2] = |
| 798 Func() | |
| 799 - No line break is allowed in between arguments of an `:echo`, `:execute` and | |
| 800 similar commands. This is OK: > | |
| 22171 | 801 echo [1, |
| 21250 | 802 2] [3, |
| 803 4] | |
| 804 < This does not work: > | |
| 22171 | 805 echo [1, 2] |
| 21250 | 806 [3, 4] |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
807 - In some cases it is difficult for Vim to parse a command, especially when |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
808 commands are used as an argument to another command, such as `windo`. In |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
809 those cases the line continuation with a backslash has to be used. |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
810 |
| 24569 | 811 |
| 812 White space ~ | |
| 27537 | 813 *E1004* *E1068* *E1069* *E1074* *E1127* *E1202* |
| 24569 | 814 Vim9 script enforces proper use of white space. This is no longer allowed: > |
| 815 var name=234 # Error! | |
| 816 var name= 234 # Error! | |
| 817 var name =234 # Error! | |
| 818 There must be white space before and after the "=": > | |
| 819 var name = 234 # OK | |
| 820 White space must also be put before the # that starts a comment after a | |
| 821 command: > | |
| 822 var name = 234# Error! | |
| 823 var name = 234 # OK | |
| 824 | |
| 825 White space is required around most operators. | |
| 826 | |
| 827 White space is required in a sublist (list slice) around the ":", except at | |
| 828 the start and end: > | |
| 829 otherlist = mylist[v : count] # v:count has a different meaning | |
| 830 otherlist = mylist[:] # make a copy of the List | |
| 831 otherlist = mylist[v :] | |
| 832 otherlist = mylist[: v] | |
| 833 | |
| 834 White space is not allowed: | |
| 835 - Between a function name and the "(": > | |
| 836 Func (arg) # Error! | |
| 837 Func | |
| 838 \ (arg) # Error! | |
| 839 Func | |
| 840 (arg) # Error! | |
| 841 Func(arg) # OK | |
| 842 Func( | |
| 843 arg) # OK | |
| 844 Func( | |
| 845 arg # OK | |
| 846 ) | |
| 27537 | 847 < *E1205* |
| 25700 | 848 White space is not allowed in a `:set` command between the option name and a |
| 849 following "&", "!", "<", "=", "+=", "-=" or "^=". | |
| 25402 | 850 |
| 24569 | 851 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
852 No curly braces expansion ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
853 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
854 |curly-braces-names| cannot be used. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
855 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
856 |
| 27537 | 857 Command modifiers are not ignored ~ |
| 858 *E1176* | |
| 859 Using a command modifier for a command that does not use it gives an error. | |
| 29533 | 860 *E1082* |
| 861 Also, using a command modifier without a following command is now an error. | |
| 27537 | 862 |
| 863 | |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
864 Dictionary literals ~ |
| 27321 | 865 *vim9-literal-dict* *E1014* |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
866 Traditionally Vim has supported dictionary literals with a {} syntax: > |
|
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
867 let dict = {'key': value} |
|
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
868 |
|
23088
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
869 Later it became clear that using a simple text key is very common, thus |
|
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
870 literal dictionaries were introduced in a backwards compatible way: > |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
871 let dict = #{key: value} |
|
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
872 |
|
23088
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
873 However, this #{} syntax is unlike any existing language. As it turns out |
|
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
874 that using a literal key is much more common than using an expression, and |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
875 considering that JavaScript uses this syntax, using the {} form for dictionary |
|
23088
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
876 literals is considered a much more useful syntax. In Vim9 script the {} form |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
877 uses literal keys: > |
| 23666 | 878 var dict = {key: value} |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
879 |
|
23088
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
880 This works for alphanumeric characters, underscore and dash. If you want to |
|
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
881 use another character, use a single or double quoted string: > |
| 23666 | 882 var dict = {'key with space': value} |
| 883 var dict = {"key\twith\ttabs": value} | |
| 884 var dict = {'': value} # empty key | |
| 27459 | 885 < *E1139* |
|
23088
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
886 In case the key needs to be an expression, square brackets can be used, just |
|
285cde4b8d0e
patch 8.2.2090: Vim9: dict does not accept a key in quotes
Bram Moolenaar <Bram@vim.org>
parents:
23047
diff
changeset
|
887 like in JavaScript: > |
| 23666 | 888 var dict = {["key" .. nr]: value} |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
889 |
|
23827
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23737
diff
changeset
|
890 The key type can be string, number, bool or float. Other types result in an |
| 28777 | 891 error. Without using [] the value is used as a string, keeping leading zeros. |
| 892 An expression given with [] is evaluated and then converted to a string. | |
| 893 Leading zeros will then be dropped: > | |
| 894 var dict = {000123: 'without', [000456]: 'with'} | |
|
23827
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23737
diff
changeset
|
895 echo dict |
| 28777 | 896 {'456': 'with', '000123': 'without'} |
| 897 A float only works inside [] because the dot is not accepted otherwise: > | |
| 898 var dict = {[00.013]: 'float'} | |
| 899 echo dict | |
| 900 {'0.013': 'float'} | |
|
23827
7e0d8f1cae7d
patch 8.2.2455: Vim9: key type for literal dict and indexing is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
23737
diff
changeset
|
901 |
|
22936
00b0275ffe7f
patch 8.2.2015: Vim9: literal dict #{} is not like any other language
Bram Moolenaar <Bram@vim.org>
parents:
22723
diff
changeset
|
902 |
|
23978
54b2aa1f0d42
patch 8.2.2531: Vim9: the :k command is obscure
Bram Moolenaar <Bram@vim.org>
parents:
23974
diff
changeset
|
903 No :xit, :t, :k, :append, :change or :insert ~ |
| 27459 | 904 *E1100* |
|
21584
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
905 These commands are too easily confused with local variable names. |
|
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
906 Instead of `:x` or `:xit` you can use `:exit`. |
|
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
907 Instead of `:t` you can use `:copy`. |
|
23978
54b2aa1f0d42
patch 8.2.2531: Vim9: the :k command is obscure
Bram Moolenaar <Bram@vim.org>
parents:
23974
diff
changeset
|
908 Instead of `:k` you can use `:mark`. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
909 |
| 19303 | 910 |
| 911 Comparators ~ | |
| 912 | |
| 913 The 'ignorecase' option is not used for comparators that use strings. | |
| 27804 | 914 Thus "=~" works like "=~#". |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
915 |
| 29756 | 916 "is" and "isnot" (|expr-is| and |expr-isnot|) when used on strings now return |
| 917 false. In legacy script they just compare the strings, in |Vim9| script they | |
| 918 check identity, and strings are copied when used, thus two strings are never | |
| 919 the same (this might change some day if strings are not copied but reference | |
| 920 counted). | |
| 921 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
922 |
| 24569 | 923 Abort after error ~ |
| 924 | |
| 925 In legacy script, when an error is encountered, Vim continues to execute | |
| 926 following lines. This can lead to a long sequence of errors and need to type | |
| 927 CTRL-C to stop it. In Vim9 script execution of commands stops at the first | |
| 928 error. Example: > | |
| 929 vim9script | |
| 930 var x = does-not-exist | |
| 931 echo 'not executed' | |
| 932 | |
| 933 | |
| 23666 | 934 For loop ~ |
| 27537 | 935 *E1254* |
| 26438 | 936 The loop variable must not be declared yet: > |
| 26304 | 937 var i = 1 |
| 938 for i in [1, 2, 3] # Error! | |
| 939 | |
| 26438 | 940 It is possible to use a global variable though: > |
| 941 g:i = 1 | |
| 942 for g:i in [1, 2, 3] | |
| 943 echo g:i | |
| 944 endfor | |
| 945 | |
| 23666 | 946 Legacy Vim script has some tricks to make a for loop over a list handle |
| 947 deleting items at the current or previous item. In Vim9 script it just uses | |
| 948 the index, if items are deleted then items in the list will be skipped. | |
| 949 Example legacy script: > | |
| 950 let l = [1, 2, 3, 4] | |
| 951 for i in l | |
| 952 echo i | |
| 953 call remove(l, index(l, i)) | |
| 954 endfor | |
| 955 Would echo: | |
| 956 1 | |
| 957 2 | |
| 958 3 | |
| 959 4 | |
| 960 In compiled Vim9 script you get: | |
| 961 1 | |
| 962 3 | |
| 963 Generally, you should not change the list that is iterated over. Make a copy | |
| 964 first if needed. | |
|
30785
02b5d6f20db2
patch 9.0.0727: help in the repository differs from patched version too much
Bram Moolenaar <Bram@vim.org>
parents:
30634
diff
changeset
|
965 When looping over a list of lists, the nested lists can be changed. The loop |
|
02b5d6f20db2
patch 9.0.0727: help in the repository differs from patched version too much
Bram Moolenaar <Bram@vim.org>
parents:
30634
diff
changeset
|
966 variable is "final", it cannot be changed but what its value can be changed. |
| 30547 | 967 *E1306* |
| 968 The depth of loops, :for and :while loops added together, cannot exceed 10. | |
| 23666 | 969 |
| 970 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
971 Conditions and expressions ~ |
| 27321 | 972 *vim9-boolean* |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
973 Conditions and expressions are mostly working like they do in other languages. |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
974 Some values are different from legacy Vim script: |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
975 value legacy Vim script Vim9 script ~ |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
976 0 falsy falsy |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
977 1 truthy truthy |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
978 99 truthy Error! |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
979 "0" falsy Error! |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
980 "99" truthy Error! |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
981 "text" falsy Error! |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
982 |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
983 For the "??" operator and when using "!" then there is no error, every value |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
984 is either falsy or truthy. This is mostly like JavaScript, except that an |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
985 empty list and dict is falsy: |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
986 |
|
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
987 type truthy when ~ |
| 23466 | 988 bool true, v:true or 1 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
989 number non-zero |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
990 float non-zero |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
991 string non-empty |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
992 blob non-empty |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
993 list non-empty (different from JavaScript) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
994 dictionary non-empty (different from JavaScript) |
| 19968 | 995 func when there is a function name |
| 23466 | 996 special true or v:true |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
997 job when not NULL |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
998 channel when not NULL |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
999 class when not NULL |
| 23466 | 1000 object when not NULL (TODO: when isTrue() returns true) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1001 |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1002 The boolean operators "||" and "&&" expect the values to be boolean, zero or |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1003 one: > |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1004 1 || false == true |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1005 0 || 1 == true |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1006 0 || false == false |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1007 1 && true == true |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1008 0 && 1 == false |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1009 8 || 0 Error! |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1010 'yes' && 0 Error! |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1011 [] || 99 Error! |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1012 |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1013 When using "!" for inverting, there is no error for using any type and the |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
1014 result is a boolean. "!!" can be used to turn any value into boolean: > |
| 23573 | 1015 !'yes' == false |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
1016 !![] == false |
| 23573 | 1017 !![1, 2, 3] == true |
|
22494
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1018 |
|
4c21f7f6f9e3
patch 8.2.1795: Vim9: operators && and || have a confusing result
Bram Moolenaar <Bram@vim.org>
parents:
22441
diff
changeset
|
1019 When using "`.."` for string concatenation arguments of simple types are |
|
22500
ef8a3177edc1
patch 8.2.1798: Vim9: trinary operator condition is too permissive
Bram Moolenaar <Bram@vim.org>
parents:
22494
diff
changeset
|
1020 always converted to string: > |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1021 'hello ' .. 123 == 'hello 123' |
| 23466 | 1022 'hello ' .. v:true == 'hello true' |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1023 |
|
26769
30972227ac8d
patch 8.2.3913: help for expressions does not mention Vim9 syntax
Bram Moolenaar <Bram@vim.org>
parents:
26755
diff
changeset
|
1024 Simple types are Number, Float, Special and Bool. For other types |string()| |
|
30972227ac8d
patch 8.2.3913: help for expressions does not mention Vim9 syntax
Bram Moolenaar <Bram@vim.org>
parents:
26755
diff
changeset
|
1025 should be used. |
| 27321 | 1026 *false* *true* *null* *E1034* |
|
28002
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1027 In Vim9 script one can use the following predefined values: > |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1028 true |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1029 false |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1030 null |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1031 null_blob |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1032 null_channel |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1033 null_dict |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1034 null_function |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1035 null_job |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1036 null_list |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1037 null_partial |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1038 null_string |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1039 `true` is the same as `v:true`, `false` the same as `v:false`, `null` the same |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1040 as `v:null`. |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1041 |
| 31028 | 1042 While `null` has the type "special", the other "null_" values have the type |
|
28002
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1043 indicated by their name. Quite often a null value is handled the same as an |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1044 empty value, but not always. The values can be useful to clear a script-local |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1045 variable, since they cannot be deleted with `:unlet`. E.g.: > |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1046 var theJob = job_start(...) |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1047 # let the job do its work |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1048 theJob = null_job |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1049 |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1050 The values can also be useful as the default value for an argument: > |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1051 def MyFunc(b: blob = null_blob) |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1052 if b == null_blob |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1053 # b argument was not given |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1054 |
| 28141 | 1055 It is possible to compare `null` with any value, this will not give a type |
| 1056 error. However, comparing `null` with a number, float or bool will always | |
| 1057 result in `false`. This is different from legacy script, where comparing | |
| 1058 `null` with zero or `false` would return `true`. | |
| 1059 | |
|
28002
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1060 When converting a boolean to a string `false` and `true` are used, not |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1061 `v:false` and `v:true` like in legacy script. `v:none` has no `none` |
|
1012048eed26
patch 8.2.4526: Vim9: cannot set variables to a null value
Bram Moolenaar <Bram@vim.org>
parents:
27903
diff
changeset
|
1062 replacement, it has no equivalent in other languages. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1063 |
|
24128
fcbb1d4df15b
patch 8.2.2605: Vim9: string index and slice does not include composing chars
Bram Moolenaar <Bram@vim.org>
parents:
24103
diff
changeset
|
1064 Indexing a string with [idx] or taking a slice with [idx : idx] uses character |
|
fcbb1d4df15b
patch 8.2.2605: Vim9: string index and slice does not include composing chars
Bram Moolenaar <Bram@vim.org>
parents:
24103
diff
changeset
|
1065 indexes instead of byte indexes. Composing characters are included. |
|
fcbb1d4df15b
patch 8.2.2605: Vim9: string index and slice does not include composing chars
Bram Moolenaar <Bram@vim.org>
parents:
24103
diff
changeset
|
1066 Example: > |
| 21825 | 1067 echo 'bár'[1] |
| 1068 In legacy script this results in the character 0xc3 (an illegal byte), in Vim9 | |
| 1069 script this results in the string 'á'. | |
| 23573 | 1070 A negative index is counting from the end, "[-1]" is the last character. |
| 23666 | 1071 To exclude the last character use |slice()|. |
|
24272
cabed216cc2f
patch 8.2.2677: Vim9: cannot use only some of the default arguments
Bram Moolenaar <Bram@vim.org>
parents:
24150
diff
changeset
|
1072 To count composing characters separately use |strcharpart()|. |
| 23573 | 1073 If the index is out of range then an empty string results. |
| 1074 | |
| 1075 In legacy script "++var" and "--var" would be silently accepted and have no | |
| 1076 effect. This is an error in Vim9 script. | |
| 1077 | |
| 1078 Numbers starting with zero are not considered to be octal, only numbers | |
| 1079 starting with "0o" are octal: "0o744". |scriptversion-4| | |
| 21825 | 1080 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1081 |
| 21093 | 1082 What to watch out for ~ |
| 1083 *vim9-gotchas* | |
| 1084 Vim9 was designed to be closer to often used programming languages, but at the | |
| 1085 same time tries to support the legacy Vim commands. Some compromises had to | |
| 1086 be made. Here is a summary of what might be unexpected. | |
| 1087 | |
| 1088 Ex command ranges need to be prefixed with a colon. > | |
| 23666 | 1089 -> legacy Vim: shifts the previous line to the right |
| 1090 ->func() Vim9: method call in a continuation line | |
| 1091 :-> Vim9: shifts the previous line to the right | |
| 21093 | 1092 |
| 23666 | 1093 %s/a/b legacy Vim: substitute on all lines |
| 21093 | 1094 x = alongname |
| 23666 | 1095 % another Vim9: modulo operator in a continuation line |
| 1096 :%s/a/b Vim9: substitute on all lines | |
| 1097 't legacy Vim: jump to mark t | |
| 1098 'text'->func() Vim9: method call | |
| 1099 :'t Vim9: jump to mark t | |
| 21093 | 1100 |
| 21676 | 1101 Some Ex commands can be confused with assignments in Vim9 script: > |
| 23666 | 1102 g:name = value # assignment |
|
25939
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1103 :g:pattern:cmd # :global command |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1104 |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1105 To avoid confusion between a `:global` or `:substitute` command and an |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1106 expression or assignment, a few separators cannot be used when these commands |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1107 are abbreviated to a single character: ':', '-' and '.'. > |
| 23666 | 1108 g:pattern:cmd # invalid command - ERROR |
|
25939
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1109 s:pattern:repl # invalid command - ERROR |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1110 g-pattern-cmd # invalid command - ERROR |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1111 s-pattern-repl # invalid command - ERROR |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1112 g.pattern.cmd # invalid command - ERROR |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1113 s.pattern.repl # invalid command - ERROR |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1114 |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1115 Also, there cannot be a space between the command and the separator: > |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1116 g /pattern/cmd # invalid command - ERROR |
|
377a7686a52f
patch 8.2.3503: Vim9: using g:pat:cmd is confusing
Bram Moolenaar <Bram@vim.org>
parents:
25836
diff
changeset
|
1117 s /pattern/repl # invalid command - ERROR |
| 21676 | 1118 |
| 21093 | 1119 Functions defined with `:def` compile the whole function. Legacy functions |
| 1120 can bail out, and the following lines are not parsed: > | |
| 1121 func Maybe() | |
| 1122 if !has('feature') | |
| 1123 return | |
| 1124 endif | |
| 1125 use-feature | |
| 1126 endfunc | |
| 1127 Vim9 functions are compiled as a whole: > | |
| 1128 def Maybe() | |
| 1129 if !has('feature') | |
| 1130 return | |
| 1131 endif | |
| 23573 | 1132 use-feature # May give a compilation error |
| 21093 | 1133 enddef |
| 1134 For a workaround, split it in two functions: > | |
| 1135 func Maybe() | |
| 1136 if has('feature') | |
| 23666 | 1137 call MaybeInner() |
| 21093 | 1138 endif |
| 1139 endfunc | |
| 1140 if has('feature') | |
| 1141 def MaybeInner() | |
| 1142 use-feature | |
| 1143 enddef | |
| 1144 endif | |
| 22171 | 1145 Or put the unsupported code inside an `if` with a constant expression that |
| 21991 | 1146 evaluates to false: > |
| 1147 def Maybe() | |
| 1148 if has('feature') | |
| 1149 use-feature | |
| 1150 endif | |
| 1151 enddef | |
| 25619 | 1152 The `exists_compiled()` function can also be used for this. |
| 1153 *vim9-user-command* | |
| 23666 | 1154 Another side effect of compiling a function is that the presence of a user |
| 23573 | 1155 command is checked at compile time. If the user command is defined later an |
| 1156 error will result. This works: > | |
| 1157 command -nargs=1 MyCommand echom <q-args> | |
| 1158 def Works() | |
| 1159 MyCommand 123 | |
| 1160 enddef | |
| 1161 This will give an error for "MyCommand" not being defined: > | |
| 1162 def Works() | |
| 1163 command -nargs=1 MyCommand echom <q-args> | |
| 1164 MyCommand 123 | |
| 1165 enddef | |
| 1166 A workaround is to invoke the command indirectly with `:execute`: > | |
| 1167 def Works() | |
| 1168 command -nargs=1 MyCommand echom <q-args> | |
| 1169 execute 'MyCommand 123' | |
| 1170 enddef | |
| 1171 | |
| 21991 | 1172 Note that for unrecognized commands there is no check for "|" and a following |
| 1173 command. This will give an error for missing `endif`: > | |
| 1174 def Maybe() | |
| 1175 if has('feature') | use-feature | endif | |
| 1176 enddef | |
| 21093 | 1177 |
| 23305 | 1178 Other differences ~ |
| 1179 | |
| 1180 Patterns are used like 'magic' is set, unless explicitly overruled. | |
| 1181 The 'edcompatible' option value is not used. | |
| 1182 The 'gdefault' option value is not used. | |
| 1183 | |
| 24387 | 1184 You may also find this wiki useful. It was written by an early adopter of |
| 24103 | 1185 Vim9 script: https://github.com/lacygoill/wiki/blob/master/vim/vim9.md |
| 23305 | 1186 |
| 25056 | 1187 *:++* *:--* |
| 1188 The ++ and -- commands have been added. They are very similar to adding or | |
| 1189 subtracting one: > | |
| 1190 ++var | |
| 1191 var += 1 | |
| 1192 --var | |
| 1193 var -= 1 | |
| 1194 | |
| 1195 Using ++var or --var in an expression is not supported yet. | |
| 1196 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1197 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1198 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1199 3. New style functions *fast-functions* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1200 |
| 27321 | 1201 *:def* *E1028* |
| 21825 | 1202 :def[!] {name}([arguments])[: {return-type}] |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1203 Define a new function by the name {name}. The body of |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1204 the function follows in the next lines, until the |
| 27321 | 1205 matching `:enddef`. *E1073* |
| 1206 *E1011* | |
| 1207 The {name} must be less than 100 bytes long. | |
| 1208 *E1003* *E1027* *E1056* *E1059* | |
| 1209 The type of value used with `:return` must match | |
| 1210 {return-type}. When {return-type} is omitted or is | |
| 1211 "void" the function is not expected to return | |
| 1212 anything. | |
| 27459 | 1213 *E1077* *E1123* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1214 {arguments} is a sequence of zero or more argument |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1215 declarations. There are three forms: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1216 {name}: {type} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1217 {name} = {value} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1218 {name}: {type} = {value} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1219 The first form is a mandatory argument, the caller |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1220 must always provide them. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1221 The second and third form are optional arguments. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1222 When the caller omits an argument the {value} is used. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1223 |
| 20856 | 1224 The function will be compiled into instructions when |
| 21499 | 1225 called, or when `:disassemble` or `:defcompile` is |
| 1226 used. Syntax and type errors will be produced at that | |
| 1227 time. | |
| 20856 | 1228 |
| 21499 | 1229 It is possible to nest `:def` inside another `:def` or |
| 1230 `:function` up to about 50 levels deep. | |
| 27459 | 1231 *E1117* |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1232 [!] is used as with `:function`. Note that |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1233 script-local functions cannot be deleted or redefined |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1234 later in Vim9 script. They can only be removed by |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1235 reloading the same script. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1236 |
| 27537 | 1237 *:enddef* *E1057* *E1152* *E1173* |
| 21499 | 1238 :enddef End of a function defined with `:def`. It should be on |
| 1239 a line by its own. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1240 |
| 24387 | 1241 You may also find this wiki useful. It was written by an early adopter of |
|
24128
fcbb1d4df15b
patch 8.2.2605: Vim9: string index and slice does not include composing chars
Bram Moolenaar <Bram@vim.org>
parents:
24103
diff
changeset
|
1242 Vim9 script: https://github.com/lacygoill/wiki/blob/master/vim/vim9.md |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1243 |
|
19473
b09afbebffee
patch 8.2.0294: cannot use Ex command that is also a function name
Bram Moolenaar <Bram@vim.org>
parents:
19404
diff
changeset
|
1244 If the script the function is defined in is Vim9 script, then script-local |
|
b09afbebffee
patch 8.2.0294: cannot use Ex command that is also a function name
Bram Moolenaar <Bram@vim.org>
parents:
19404
diff
changeset
|
1245 variables can be accessed without the "s:" prefix. They must be defined |
| 20856 | 1246 before the function is compiled. If the script the function is defined in is |
| 1247 legacy script, then script-local variables must be accessed with the "s:" | |
| 24387 | 1248 prefix if they do not exist at the time of compiling. |
| 29533 | 1249 *E1269* |
| 1250 Script-local variables in a |Vim9| script must be declared at the script | |
| 1251 level. They cannot be created in a function, also not in a legacy function. | |
|
19473
b09afbebffee
patch 8.2.0294: cannot use Ex command that is also a function name
Bram Moolenaar <Bram@vim.org>
parents:
19404
diff
changeset
|
1252 |
| 20552 | 1253 *:defc* *:defcompile* |
| 1254 :defc[ompile] Compile functions defined in the current script that | |
| 1255 were not compiled yet. | |
|
28934
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1256 This will report any errors found during compilation. |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1257 |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1258 :defc[ompile] {func} |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1259 :defc[ompile] debug {func} |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1260 :defc[ompile] profile {func} |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1261 Compile function {func}, if needed. Use "debug" and |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1262 "profile" to specify the compilation mode. |
|
a712ea475390
patch 8.2.4989: cannot specify a function name for :defcompile
Bram Moolenaar <Bram@vim.org>
parents:
28862
diff
changeset
|
1263 This will report any errors found during compilation. |
|
19473
b09afbebffee
patch 8.2.0294: cannot use Ex command that is also a function name
Bram Moolenaar <Bram@vim.org>
parents:
19404
diff
changeset
|
1264 |
| 19404 | 1265 *:disa* *:disassemble* |
| 1266 :disa[ssemble] {func} Show the instructions generated for {func}. | |
| 27321 | 1267 This is for debugging and testing. *E1061* |
|
19556
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
1268 Note that for command line completion of {func} you |
|
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
1269 can prepend "s:" to find script-local functions. |
| 19404 | 1270 |
| 24911 | 1271 :disa[ssemble] profile {func} |
| 1272 Like `:disassemble` but with the instructions used for | |
| 23737 | 1273 profiling. |
| 1274 | |
| 24911 | 1275 :disa[ssemble] debug {func} |
| 1276 Like `:disassemble` but with the instructions used for | |
| 1277 debugging. | |
| 1278 | |
| 21250 | 1279 Limitations ~ |
| 1280 | |
| 1281 Local variables will not be visible to string evaluation. For example: > | |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
1282 def MapList(): list<string> |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1283 var list = ['aa', 'bb', 'cc', 'dd'] |
| 21250 | 1284 return range(1, 2)->map('list[v:val]') |
| 1285 enddef | |
| 1286 | |
| 1287 The map argument is a string expression, which is evaluated without the | |
| 1288 function scope. Instead, use a lambda: > | |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
1289 def MapList(): list<string> |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1290 var list = ['aa', 'bb', 'cc', 'dd'] |
| 25973 | 1291 return range(1, 2)->map((_, v) => list[v]) |
| 21250 | 1292 enddef |
| 1293 | |
|
26358
80b555c4aed0
patch 8.2.3710: Vim9: backtick expression expanded for :global
Bram Moolenaar <Bram@vim.org>
parents:
26346
diff
changeset
|
1294 For commands that are not compiled, such as `:edit`, backtick expansion can be |
|
80b555c4aed0
patch 8.2.3710: Vim9: backtick expression expanded for :global
Bram Moolenaar <Bram@vim.org>
parents:
26346
diff
changeset
|
1295 used and it can use the local scope. Example: > |
|
23358
b3142fc0a414
patch 8.2.2222: Vim9: cannot keep script variables when reloading
Bram Moolenaar <Bram@vim.org>
parents:
23318
diff
changeset
|
1296 def Replace() |
|
26358
80b555c4aed0
patch 8.2.3710: Vim9: backtick expression expanded for :global
Bram Moolenaar <Bram@vim.org>
parents:
26346
diff
changeset
|
1297 var fname = 'blah.txt' |
|
80b555c4aed0
patch 8.2.3710: Vim9: backtick expression expanded for :global
Bram Moolenaar <Bram@vim.org>
parents:
26346
diff
changeset
|
1298 edit `=fname` |
| 25402 | 1299 enddef |
| 1300 | |
| 24278 | 1301 Closures defined in a loop will share the same context. For example: > |
| 1302 var flist: list<func> | |
| 25402 | 1303 for i in range(5) |
| 24278 | 1304 var inloop = i |
| 1305 flist[i] = () => inloop | |
| 1306 endfor | |
| 25402 | 1307 echo range(5)->map((i, _) => flist[i]()) |
| 1308 # Result: [4, 4, 4, 4, 4] | |
| 28141 | 1309 < *E1271* |
| 1310 A closure must be compiled in the context that it is defined in, so that | |
| 1311 variables in that context can be found. This mostly happens correctly, except | |
| 1312 when a function is marked for debugging with `breakadd` after it was compiled. | |
| 28246 | 1313 Make sure to define the breakpoint before compiling the outer function. |
| 24278 | 1314 |
| 1315 The "inloop" variable will exist only once, all closures put in the list refer | |
| 25402 | 1316 to the same instance, which in the end will have the value 4. This is |
| 1317 efficient, also when looping many times. If you do want a separate context | |
| 30202 | 1318 for each closure, call a function to define it: > |
| 25402 | 1319 def GetClosure(i: number): func |
| 1320 var infunc = i | |
| 1321 return () => infunc | |
| 24278 | 1322 enddef |
| 1323 | |
| 1324 var flist: list<func> | |
| 25402 | 1325 for i in range(5) |
| 1326 flist[i] = GetClosure(i) | |
| 24278 | 1327 endfor |
| 25402 | 1328 echo range(5)->map((i, _) => flist[i]()) |
| 1329 # Result: [0, 1, 2, 3, 4] | |
| 24278 | 1330 |
| 27537 | 1331 In some situations, especially when calling a Vim9 closure from legacy |
| 1332 context, the evaluation will fail. *E1248* | |
| 1333 | |
| 30202 | 1334 Note that at the script level the loop variable will be invalid after the |
| 1335 loop, also when used in a closure that is called later, e.g. with a timer. | |
| 1336 This will generate error |E1302|: > | |
| 1337 for n in range(4) | |
| 1338 timer_start(500 * n, (_) => { | |
| 1339 echowin n | |
| 1340 }) | |
| 1341 endfor | |
| 1342 | |
| 30324 | 1343 You need to use a block and define a variable there, and use that one in the |
| 1344 closure: > | |
| 30202 | 1345 for n in range(4) |
| 30324 | 1346 { |
| 1347 var nr = n | |
| 1348 timer_start(500 * n, (_) => { | |
| 1349 echowin nr | |
| 1350 }) | |
| 1351 } | |
| 30202 | 1352 endfor |
| 1353 | |
| 1354 Using `echowindow` is useful in a timer, the messages go into a popup and will | |
| 1355 not interfere with what the user is doing when it triggers. | |
| 1356 | |
| 27537 | 1357 |
| 1358 Converting a function from legacy to Vim9 ~ | |
| 1359 *convert_legacy_function_to_vim9* | |
| 1360 These are the most changes that need to be made to convert a legacy function | |
| 1361 to a Vim9 function: | |
| 1362 | |
| 1363 - Change `func` or `function` to `def`. | |
| 1364 - Change `endfunc` or `endfunction` to `enddef`. | |
| 1365 - Add types to the function arguments. | |
| 1366 - If the function returns something, add the return type. | |
| 1367 - Change comments to start with # instead of ". | |
| 1368 | |
| 1369 For example, a legacy function: > | |
| 1370 func MyFunc(text) | |
| 1371 " function body | |
| 1372 endfunc | |
| 1373 < Becomes: > | |
| 1374 def MyFunc(text: string): number | |
| 1375 # function body | |
| 1376 enddef | |
| 1377 | |
| 1378 - Remove "a:" used for arguments. E.g.: > | |
| 1379 return len(a:text) | |
| 1380 < Becomes: > | |
| 1381 return len(text) | |
| 1382 | |
| 1383 - Change `let` used to declare a variable to `var`. | |
| 1384 - Remove `let` used to assign a value to a variable. This is for local | |
| 1385 variables already declared and b: w: g: and t: variables. | |
| 1386 | |
| 1387 For example, legacy function: > | |
| 1388 let lnum = 1 | |
| 1389 let lnum += 3 | |
| 1390 let b:result = 42 | |
| 1391 < Becomes: > | |
| 1392 var lnum = 1 | |
| 1393 lnum += 3 | |
| 1394 b:result = 42 | |
| 1395 | |
| 1396 - Insert white space in expressions where needed. | |
| 1397 - Change "." used for concatenation to "..". | |
| 1398 | |
| 1399 For example, legacy function: > | |
| 1400 echo line(1).line(2) | |
| 1401 < Becomes: > | |
| 1402 echo line(1) .. line(2) | |
| 1403 | |
| 1404 - line continuation does not always require a backslash: > | |
| 1405 echo ['one', | |
| 1406 \ 'two', | |
| 1407 \ 'three' | |
| 1408 \ ] | |
| 1409 < Becomes: > | |
| 1410 echo ['one', | |
| 1411 'two', | |
| 1412 'three' | |
| 1413 ] | |
| 1414 | |
|
30594
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1415 |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1416 Calling a function in an expr option ~ |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1417 *expr-option-function* |
| 30634 | 1418 The value of a few options, such as 'foldexpr', is an expression that is |
| 1419 evaluated to get a value. The evaluation can have quite a bit of overhead. | |
| 1420 One way to minimize the overhead, and also to keep the option value very | |
| 1421 simple, is to define a compiled function and set the option to call it | |
| 1422 without arguments. Example: > | |
|
30594
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1423 vim9script |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1424 def MyFoldFunc(): any |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1425 ... compute fold level for line v:lnum |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1426 return level |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1427 enddef |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1428 set foldexpr=s:MyFoldFunc() |
|
586b5b3aacf9
patch 9.0.0632: calling a function from an "expr" option has overhead
Bram Moolenaar <Bram@vim.org>
parents:
30547
diff
changeset
|
1429 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1430 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1431 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1432 4. Types *vim9-types* |
| 27321 | 1433 *E1008* *E1009* *E1010* *E1012* |
| 1434 *E1013* *E1029* *E1030* | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1435 The following builtin types are supported: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1436 bool |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1437 number |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1438 float |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1439 string |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1440 blob |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1441 list<{type}> |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1442 dict<{type}> |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1443 job |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1444 channel |
| 19646 | 1445 func |
| 19968 | 1446 func: {type} |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1447 func({type}, ...) |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1448 func({type}, ...): {type} |
| 27321 | 1449 void |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1450 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1451 Not supported yet: |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1452 tuple<a: {type}, b: {type}, ...> |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1453 |
| 25161 | 1454 These types can be used in declarations, but no simple value will actually |
| 27321 | 1455 have the "void" type. Trying to use a void (e.g. a function without a |
| 27537 | 1456 return value) results in error *E1031* *E1186* . |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1457 |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1458 There is no array type, use list<{type}> instead. For a list constant an |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1459 efficient implementation is used that avoids allocating lot of small pieces of |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1460 memory. |
| 27321 | 1461 *E1005* *E1007* |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1462 A partial and function can be declared in more or less specific ways: |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1463 func any kind of function reference, no type |
| 19968 | 1464 checking for arguments or return value |
| 25161 | 1465 func: void any number and type of arguments, no return |
| 1466 value | |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1467 func: {type} any number and type of arguments with specific |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1468 return type |
| 25161 | 1469 |
| 1470 func() function with no argument, does not return a | |
| 1471 value | |
| 1472 func(): void same | |
| 1473 func(): {type} function with no argument and return type | |
| 1474 | |
| 19968 | 1475 func({type}) function with argument type, does not return |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1476 a value |
| 19968 | 1477 func({type}): {type} function with argument type and return type |
| 1478 func(?{type}) function with type of optional argument, does | |
| 1479 not return a value | |
| 1480 func(...{type}) function with type of variable number of | |
| 1481 arguments, does not return a value | |
| 1482 func({type}, ?{type}, ...{type}): {type} | |
| 1483 function with: | |
| 1484 - type of mandatory argument | |
| 1485 - type of optional argument | |
| 1486 - type of variable number of arguments | |
| 1487 - return type | |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1488 |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1489 If the return type is "void" the function does not return a value. |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1490 |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1491 The reference can also be a |Partial|, in which case it stores extra arguments |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1492 and/or a dictionary, which are not visible to the caller. Since they are |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
1493 called in the same way the declaration is the same. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1494 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1495 Custom types can be defined with `:type`: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1496 :type MyList list<string> |
|
21715
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1497 Custom types must start with a capital letter, to avoid name clashes with |
|
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1498 builtin types added later, similarly to user functions. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1499 {not implemented yet} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1500 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1501 And classes and interfaces can be used as types: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1502 :class MyClass |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1503 :var mine: MyClass |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1504 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1505 :interface MyInterface |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1506 :var mine: MyInterface |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1507 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1508 :class MyTemplate<Targ> |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1509 :var mine: MyTemplate<number> |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1510 :var mine: MyTemplate<string> |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1511 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1512 :class MyInterface<Targ> |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1513 :var mine: MyInterface<number> |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1514 :var mine: MyInterface<string> |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1515 {not implemented yet} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1516 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1517 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1518 Variable types and type casting ~ |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1519 *variable-types* |
|
21717
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1520 Variables declared in Vim9 script or in a `:def` function have a type, either |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1521 specified explicitly or inferred from the initialization. |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1522 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1523 Global, buffer, window and tab page variables do not have a specific type, the |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1524 value can be changed at any time, possibly changing the type. Therefore, in |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1525 compiled code the "any" type is assumed. |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1526 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1527 This can be a problem when the "any" type is undesired and the actual type is |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1528 expected to always be the same. For example, when declaring a list: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1529 var l: list<number> = [1, g:two] |
| 23305 | 1530 At compile time Vim doesn't know the type of "g:two" and the expression type |
| 1531 becomes list<any>. An instruction is generated to check the list type before | |
| 1532 doing the assignment, which is a bit inefficient. | |
| 27459 | 1533 *type-casting* *E1104* |
| 23305 | 1534 To avoid this, use a type cast: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1535 var l: list<number> = [1, <number>g:two] |
| 23305 | 1536 The compiled code will then only check that "g:two" is a number and give an |
| 1537 error if it isn't. This is called type casting. | |
|
21717
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1538 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1539 The syntax of a type cast is: "<" {type} ">". There cannot be white space |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1540 after the "<" or before the ">" (to avoid them being confused with |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1541 smaller-than and bigger-than operators). |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1542 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1543 The semantics is that, if needed, a runtime type check is performed. The |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1544 value is not actually changed. If you need to change the type, e.g. to change |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1545 it to a string, use the |string()| function. Or use |str2nr()| to convert a |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1546 string to a number. |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1547 |
| 29533 | 1548 If a type is given where it is not expected you can get *E1272* . |
| 1549 | |
|
21717
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
1550 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1551 Type inference ~ |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1552 *type-inference* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1553 In general: Whenever the type is clear it can be omitted. For example, when |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1554 declaring a variable and giving it a value: > |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1555 var name = 0 # infers number type |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1556 var name = 'hello' # infers string type |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1557 |
|
21715
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1558 The type of a list and dictionary comes from the common type of the values. |
|
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1559 If the values all have the same type, that type is used for the list or |
|
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1560 dictionary. If there is a mix of types, the "any" type is used. > |
|
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1561 [1, 2, 3] list<number> |
|
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1562 ['a', 'b', 'c'] list<string> |
|
571832713efa
patch 8.2.1407: Vim9: type of list and dict only depends on first item
Bram Moolenaar <Bram@vim.org>
parents:
21676
diff
changeset
|
1563 [1, 'x', 3] list<any> |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1564 |
| 25161 | 1565 The common type of function references, if they do not all have the same |
| 1566 number of arguments, uses "(...)" to indicate the number of arguments is not | |
| 1567 specified. For example: > | |
| 1568 def Foo(x: bool) | |
| 1569 enddef | |
| 1570 def Bar(x: bool, y: bool) | |
| 1571 enddef | |
| 1572 var funclist = [Foo, Bar] | |
| 1573 echo funclist->typename() | |
| 1574 Results in: | |
| 1575 list<func(...)> | |
| 1576 | |
| 24387 | 1577 For script-local variables in Vim9 script the type is checked, also when the |
| 1578 variable was declared in a legacy function. | |
| 1579 | |
| 27623 | 1580 When a type has been declared this is attached to a List or Dictionary. When |
| 27459 | 1581 later some expression attempts to change the type an error will be given: > |
| 1582 var ll: list<number> = [1, 2, 3] | |
| 27492 | 1583 ll->extend(['x']) # Error, 'x' is not a number |
| 27459 | 1584 |
| 27623 | 1585 If the type is not declared then it is allowed to change: > |
| 27492 | 1586 [1, 2, 3]->extend(['x']) # result: [1, 2, 3, 'x'] |
| 27459 | 1587 |
| 27623 | 1588 For a variable declaration an inferred type matters: > |
| 1589 var ll = [1, 2, 3] | |
| 1590 ll->extend(['x']) # Error, 'x' is not a number | |
| 1591 That is because the declaration looks like a list of numbers, thus is | |
| 1592 equivalent to: > | |
| 1593 var ll: list<number> = [1, 2, 3] | |
| 1594 If you do want a more permissive list you need to declare the type: > | |
| 1595 var ll: list<any = [1, 2, 3] | |
| 1596 ll->extend(['x']) # OK | |
| 1597 | |
| 21991 | 1598 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1599 Stricter type checking ~ |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1600 *type-checking* |
| 21991 | 1601 In legacy Vim script, where a number was expected, a string would be |
| 1602 automatically converted to a number. This was convenient for an actual number | |
| 24387 | 1603 such as "123", but leads to unexpected problems (and no error message) if the |
| 21991 | 1604 string doesn't start with a number. Quite often this leads to hard-to-find |
| 27804 | 1605 bugs. e.g.: > |
| 1606 echo 123 == '123' | |
| 1607 < 1 ~ | |
| 1608 With an accidental space: > | |
| 1609 echo 123 == ' 123' | |
| 1610 < 0 ~ | |
| 27537 | 1611 *E1206* *E1210* *E1212* |
| 21991 | 1612 In Vim9 script this has been made stricter. In most places it works just as |
| 27804 | 1613 before if the value used matches the expected type. There will sometimes be |
| 22171 | 1614 an error, thus breaking backwards compatibility. For example: |
| 21991 | 1615 - Using a number other than 0 or 1 where a boolean is expected. *E1023* |
| 25161 | 1616 - Using a string value when setting a number option. |
| 27459 | 1617 - Using a number where a string is expected. *E1024* *E1105* |
| 21991 | 1618 |
| 25973 | 1619 One consequence is that the item type of a list or dict given to |map()| must |
| 27804 | 1620 not change, if the type was declared. This will give an error in Vim9 |
| 1621 script: > | |
| 1622 var mylist: list<number> = [1, 2, 3] | |
| 1623 echo map(mylist, (i, v) => 'item ' .. i) | |
| 1624 < E1012: Type mismatch; expected number but got string in map() ~ | |
| 25161 | 1625 |
| 27804 | 1626 Instead use |mapnew()|, it creates a new list: > |
| 1627 var mylist: list<number> = [1, 2, 3] | |
| 1628 echo mapnew(mylist, (i, v) => 'item ' .. i) | |
| 1629 < ['item 0', 'item 1', 'item 2'] ~ | |
| 1630 | |
| 1631 If the item type was not declared or determined to be "any" it can change to a | |
| 1632 more specific type. E.g. when a list of mixed types gets changed to a list of | |
| 1633 strings: > | |
| 25161 | 1634 var mylist = [1, 2.0, '3'] |
| 1635 # typename(mylist) == "list<any>" | |
| 1636 map(mylist, (i, v) => 'item ' .. i) | |
| 1637 # typename(mylist) == "list<string>", no error | |
| 27804 | 1638 |
| 1639 There is a subtle difference between using a list constant directly and | |
|
27843
532a0c5de1ec
patch 8.2.4447: Vim9: can still use s:var in a compiled function
Bram Moolenaar <Bram@vim.org>
parents:
27804
diff
changeset
|
1640 through a variable declaration. Because of type inference, when using a list |
| 27804 | 1641 constant to initialize a variable, this also sets the declared type: > |
| 1642 var mylist = [1, 2, 3] | |
| 1643 # typename(mylist) == "list<number>" | |
| 1644 echo map(mylist, (i, v) => 'item ' .. i) # Error! | |
| 1645 | |
| 1646 When using the list constant directly, the type is not declared and is allowed | |
| 1647 to change: > | |
| 1648 echo map([1, 2, 3], (i, v) => 'item ' .. i) # OK | |
| 1649 | |
| 1650 The reasoning behind this is that when a type is declared and the list is | |
| 1651 passed around and changed, the declaration must always hold. So that you can | |
| 1652 rely on the type to match the declared type. For a constant this is not | |
| 1653 needed. | |
| 1654 | |
| 1655 *E1158* | |
| 24024 | 1656 Same for |extend()|, use |extendnew()| instead, and for |flatten()|, use |
| 27804 | 1657 |flattennew()| instead. Since |flatten()| is intended to always change the |
| 1658 type, it can not be used in Vim9 script. | |
| 1659 | |
| 27537 | 1660 *E1211* *E1217* *E1218* *E1219* *E1220* *E1221* |
| 1661 *E1222* *E1223* *E1224* *E1225* *E1226* *E1227* | |
| 1662 *E1228* *E1238* *E1250* *E1251* *E1252* *E1253* | |
| 30202 | 1663 *E1256* *E1297* *E1298* *E1301* |
| 27537 | 1664 Types are checked for most builtin functions to make it easier to spot |
| 1665 mistakes. | |
| 23573 | 1666 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1667 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1668 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1669 5. Namespace, Import and Export |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1670 *vim9script* *vim9-export* *vim9-import* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1671 |
| 27162 | 1672 A Vim9 script can be written to be imported. This means that some items are |
| 1673 intentionally exported, made available to other scripts. When the exporting | |
| 1674 script is imported in another script, these exported items can then be used in | |
| 1675 that script. All the other items remain script-local in the exporting script | |
| 1676 and cannot be accessed by the importing script. | |
| 27036 | 1677 |
| 1678 This mechanism exists for writing a script that can be sourced (imported) by | |
| 1679 other scripts, while making sure these other scripts only have access to what | |
| 1680 you want them to. This also avoids using the global namespace, which has a | |
| 29121 | 1681 risk of name collisions. For example when you have two plugins with similar |
| 27036 | 1682 functionality. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1683 |
| 27162 | 1684 You can cheat by using the global namespace explicitly. That should be done |
| 1685 only for things that really are global. | |
| 21991 | 1686 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1687 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1688 Namespace ~ |
|
23392
517fca70e084
patch 8.2.2239: Vim9: concatenating lines with backslash is inconvenient
Bram Moolenaar <Bram@vim.org>
parents:
23360
diff
changeset
|
1689 *vim9-namespace* |
| 19303 | 1690 To recognize a file that can be imported the `vim9script` statement must |
|
23974
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1691 appear as the first statement in the file (see |vim9-mix| for an exception). |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1692 It tells Vim to interpret the script in its own namespace, instead of the |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1693 global namespace. If a file starts with: > |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1694 vim9script |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1695 var myvar = 'yes' |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1696 Then "myvar" will only exist in this file. While without `vim9script` it would |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1697 be available as `g:myvar` from any other script and function. |
| 27459 | 1698 *E1101* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1699 The variables at the file level are very much like the script-local "s:" |
| 20115 | 1700 variables in legacy Vim script, but the "s:" is omitted. And they cannot be |
| 1701 deleted. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1702 |
| 20115 | 1703 In Vim9 script the global "g:" namespace can still be used as before. And the |
| 1704 "w:", "b:" and "t:" namespaces. These have in common that variables are not | |
| 30324 | 1705 declared, have no specific type and they can be deleted. *E1304* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1706 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1707 A side effect of `:vim9script` is that the 'cpoptions' option is set to the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1708 Vim default value, like with: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1709 :set cpo&vim |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1710 One of the effects is that |line-continuation| is always enabled. |
|
24150
4919f2d8d7fd
patch 8.2.2616: Vim9: if 'cpo' is change in Vim9 script it may be restored
Bram Moolenaar <Bram@vim.org>
parents:
24128
diff
changeset
|
1711 The original value of 'cpoptions' is restored at the end of the script, while |
|
4919f2d8d7fd
patch 8.2.2616: Vim9: if 'cpo' is change in Vim9 script it may be restored
Bram Moolenaar <Bram@vim.org>
parents:
24128
diff
changeset
|
1712 flags added or removed in the script are also added to or removed from the |
|
4919f2d8d7fd
patch 8.2.2616: Vim9: if 'cpo' is change in Vim9 script it may be restored
Bram Moolenaar <Bram@vim.org>
parents:
24128
diff
changeset
|
1713 original value to get the same effect. The order of flags may change. |
|
26745
dcd1c244e332
patch 8.2.3901: Vim9: Cannot set 'cpo' in main .vimrc if using Vim9 script
Bram Moolenaar <Bram@vim.org>
parents:
26708
diff
changeset
|
1714 In the |vimrc| file sourced on startup this does not happen. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1715 |
|
23974
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1716 *vim9-mix* |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1717 There is one way to use both legacy and Vim9 syntax in one script file: > |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1718 " comments may go here |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1719 if !has('vim9script') |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1720 " legacy script commands go here |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1721 finish |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1722 endif |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1723 vim9script |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1724 # Vim9 script commands go here |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1725 This allows for writing a script that takes advantage of the Vim9 script |
| 24024 | 1726 syntax if possible, but will also work on a Vim version without it. |
|
23974
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1727 |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1728 This can only work in two ways: |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1729 1. The "if" statement evaluates to false, the commands up to `endif` are |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1730 skipped and `vim9script` is then the first command actually executed. |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1731 2. The "if" statement evaluates to true, the commands up to `endif` are |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1732 executed and `finish` bails out before reaching `vim9script`. |
|
d4f7e4138544
patch 8.2.2529: Vim9: Not possible to use legacy and Vim9 script in one file
Bram Moolenaar <Bram@vim.org>
parents:
23938
diff
changeset
|
1733 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1734 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1735 Export ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1736 *:export* *:exp* |
| 21499 | 1737 Exporting an item can be written as: > |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1738 export const EXPORTED_CONST = 1234 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1739 export var someValue = ... |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1740 export final someValue = ... |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1741 export const someValue = ... |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1742 export def MyFunc() ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1743 export class MyClass ... |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1744 export interface MyClass ... |
| 27321 | 1745 < *E1043* *E1044* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1746 As this suggests, only constants, variables, `:def` functions and classes can |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1747 be exported. {not implemented yet: class, interface} |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1748 |
| 20856 | 1749 *E1042* |
| 1750 `:export` can only be used in Vim9 script, at the script level. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1751 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1752 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1753 Import ~ |
| 29533 | 1754 *:import* *:imp* *E1094* *E1047* *E1262* |
| 1755 *E1048* *E1049* *E1053* *E1071* *E1088* *E1236* | |
| 29403 | 1756 The exported items can be imported in another script. The import syntax has |
| 1757 two forms. The simple form: > | |
| 1758 import {filename} | |
| 1759 < | |
| 1760 Where {filename} is an expression that must evaluate to a string. In this | |
| 1761 form the filename should end in ".vim" and the portion before ".vim" will | |
| 1762 become the script local name of the namespace. For example: > | |
|
26980
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1763 import "myscript.vim" |
| 29403 | 1764 < |
| 1765 This makes each exported item in "myscript.vim" available as "myscript.item". | |
| 27537 | 1766 *:import-as* *E1257* *E1261* |
| 29403 | 1767 In case the name is long or ambiguous, this form can be used to specify |
| 1768 another name: > | |
| 1769 import {longfilename} as {name} | |
| 1770 < | |
| 1771 In this form {name} becomes a specific script local name for the imported | |
| 1772 namespace. Therefore {name} must consist of letters, digits and '_', like | |
| 1773 |internal-variables|. The {longfilename} expression must evaluate to any | |
| 1774 filename. For example: > | |
| 1775 import "thatscript.vim.v2" as that | |
| 27537 | 1776 < *E1060* *E1258* *E1259* *E1260* |
| 29403 | 1777 Then you can use "that.item", etc. You are free to choose the name "that". |
| 1778 Use something that will be recognized as referring to the imported script. | |
| 1779 Avoid command names, command modifiers and builtin function names, because the | |
| 1780 name will shadow them. Better not start the name starts with a capital | |
| 1781 letter, since it can then also shadow global user commands and functions. | |
| 1782 Also, you cannot use the name for something else in the script, such as a | |
| 1783 function or variable name. | |
|
26980
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1784 |
| 27036 | 1785 In case the dot in the name is undesired, a local reference can be made for a |
| 1786 function: > | |
| 1787 var LongFunc = that.LongFuncName | |
|
26980
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1788 |
|
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1789 This also works for constants: > |
| 27036 | 1790 const MAXLEN = that.MAX_LEN_OF_NAME |
|
26980
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1791 |
| 27036 | 1792 This does not work for variables, since the value would be copied once and |
| 1793 when changing the variable the copy will change, not the original variable. | |
| 1794 You will need to use the full name, with the dot. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1795 |
|
25282
9bce044c7643
patch 8.2.3178: Vim9: the file name of an :import cannot be an expression
Bram Moolenaar <Bram@vim.org>
parents:
25161
diff
changeset
|
1796 `:import` can not be used in a function. Imported items are intended to exist |
|
9bce044c7643
patch 8.2.3178: Vim9: the file name of an :import cannot be an expression
Bram Moolenaar <Bram@vim.org>
parents:
25161
diff
changeset
|
1797 at the script level and only imported once. |
|
9bce044c7643
patch 8.2.3178: Vim9: the file name of an :import cannot be an expression
Bram Moolenaar <Bram@vim.org>
parents:
25161
diff
changeset
|
1798 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1799 The script name after `import` can be: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1800 - A relative path, starting "." or "..". This finds a file relative to the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1801 location of the script file itself. This is useful to split up a large |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1802 plugin into several files. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1803 - An absolute path, starting with "/" on Unix or "D:/" on MS-Windows. This |
| 22723 | 1804 will rarely be used. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1805 - A path not being relative or absolute. This will be found in the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1806 "import" subdirectories of 'runtimepath' entries. The name will usually be |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1807 longer and unique, to avoid loading the wrong file. |
| 25619 | 1808 Note that "after/import" is not used. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1809 |
| 27036 | 1810 If the name does not end in ".vim" then the use of "as name" is required. |
| 1811 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1812 Once a vim9 script file has been imported, the result is cached and used the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1813 next time the same script is imported. It will not be read again. |
|
26980
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1814 |
|
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1815 It is not allowed to import the same script twice, also when using two |
|
8796f1384750
patch 8.2.4019: Vim9: import mechanism is too complicated
Bram Moolenaar <Bram@vim.org>
parents:
26873
diff
changeset
|
1816 different "as" names. |
| 27036 | 1817 |
| 1818 When using the imported name the dot and the item name must be in the same | |
| 1819 line, there can be no line break: > | |
| 1820 echo that. | |
| 1821 name # Error! | |
| 1822 echo that | |
| 1823 .name # Error! | |
| 29659 | 1824 < *import-map* |
| 29403 | 1825 When you've imported a function from one script into a vim9 script you can |
| 1826 refer to the imported function in a mapping by prefixing it with |<SID>|: > | |
|
28447
6f753a8125f0
patch 8.2.4748: cannot use an imported function in a mapping
Bram Moolenaar <Bram@vim.org>
parents:
28405
diff
changeset
|
1827 noremap <silent> ,a :call <SID>name.Function()<CR> |
|
6f753a8125f0
patch 8.2.4748: cannot use an imported function in a mapping
Bram Moolenaar <Bram@vim.org>
parents:
28405
diff
changeset
|
1828 |
|
6f753a8125f0
patch 8.2.4748: cannot use an imported function in a mapping
Bram Moolenaar <Bram@vim.org>
parents:
28405
diff
changeset
|
1829 When the mapping is defined "<SID>name." will be replaced with <SNR> and the |
|
6f753a8125f0
patch 8.2.4748: cannot use an imported function in a mapping
Bram Moolenaar <Bram@vim.org>
parents:
28405
diff
changeset
|
1830 script ID of the imported script. |
| 29121 | 1831 An even simpler solution is using |<ScriptCmd>|: > |
| 1832 noremap ,a <ScriptCmd>name.Function()<CR> | |
| 29403 | 1833 |
| 1834 Note that this does not work for variables, only for functions. | |
| 1835 | |
| 1836 *import-legacy* *legacy-import* | |
| 1837 `:import` can also be used in legacy Vim script. The imported namespace still | |
| 1838 becomes script-local, even when the "s:" prefix is not given. For example: > | |
| 1839 import "myfile.vim" | |
| 1840 call s:myfile.MyFunc() | |
| 1841 | |
| 1842 And using the "as name" form: > | |
| 1843 import "otherfile.vim9script" as that | |
| 1844 call s:that.OtherFunc() | |
| 1845 | |
| 30324 | 1846 However, the namespace cannot be resolved on its own: > |
| 29403 | 1847 import "that.vim" |
| 1848 echo s:that | |
| 1849 " ERROR: E1060: Expected dot after name: s:that | |
| 1850 < | |
| 1851 This also affects the use of |<SID>| in the legacy mapping context. Since | |
| 1852 |<SID>| is only a valid prefix for a function and NOT for a namespace, you | |
| 1853 cannot use it | |
| 1854 to scope a function in a script local namespace. Instead of prefixing the | |
| 1855 function with |<SID>| you should use|<ScriptCmd>|. For example: > | |
| 1856 noremap ,a <ScriptCmd>:call s:that.OtherFunc()<CR> | |
| 29121 | 1857 < |
|
28447
6f753a8125f0
patch 8.2.4748: cannot use an imported function in a mapping
Bram Moolenaar <Bram@vim.org>
parents:
28405
diff
changeset
|
1858 *:import-cycle* |
| 27537 | 1859 The `import` commands are executed when encountered. If script A imports |
| 1860 script B, and B (directly or indirectly) imports A, this will be skipped over. | |
| 1861 At this point items in A after "import B" will not have been processed and | |
| 1862 defined yet. Therefore cyclic imports can exist and not result in an error | |
| 1863 directly, but may result in an error for items in A after "import B" not being | |
| 1864 defined. This does not apply to autoload imports, see the next section. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1865 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1866 |
| 27162 | 1867 Importing an autoload script ~ |
| 29840 | 1868 *vim9-autoload* *import-autoload* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1869 For optimal startup speed, loading scripts should be postponed until they are |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1870 actually needed. Using the autoload mechanism is recommended: |
| 27537 | 1871 *E1264* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1872 1. In the plugin define user commands, functions and/or mappings that refer to |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1873 items imported from an autoload script. > |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1874 import autoload 'for/search.vim' |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1875 command -nargs=1 SearchForStuff search.Stuff(<f-args>) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1876 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1877 < This goes in .../plugin/anyname.vim. "anyname.vim" can be freely chosen. |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1878 The "SearchForStuff" command is now available to the user. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1879 |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1880 The "autoload" argument to `:import` means that the script is not loaded |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1881 until one of the items is actually used. The script will be found under |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1882 the "autoload" directory in 'runtimepath' instead of the "import" |
| 28379 | 1883 directory. Alternatively a relative or absolute name can be used, see |
| 1884 below. | |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1885 |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1886 2. In the autoload script put the bulk of the code. > |
|
27215
5b54f413d132
patch 8.2.4136: Vim9: the "autoload" argument of ":vim9script" is not useful
Bram Moolenaar <Bram@vim.org>
parents:
27162
diff
changeset
|
1887 vim9script |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1888 export def Stuff(arg: string) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1889 ... |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1890 |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1891 < This goes in .../autoload/for/search.vim. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1892 |
|
27215
5b54f413d132
patch 8.2.4136: Vim9: the "autoload" argument of ":vim9script" is not useful
Bram Moolenaar <Bram@vim.org>
parents:
27162
diff
changeset
|
1893 Putting the "search.vim" script under the "/autoload/for/" directory has |
|
5b54f413d132
patch 8.2.4136: Vim9: the "autoload" argument of ":vim9script" is not useful
Bram Moolenaar <Bram@vim.org>
parents:
27162
diff
changeset
|
1894 the effect that "for#search#" will be prefixed to every exported item. The |
|
5b54f413d132
patch 8.2.4136: Vim9: the "autoload" argument of ":vim9script" is not useful
Bram Moolenaar <Bram@vim.org>
parents:
27162
diff
changeset
|
1895 prefix is obtained from the file name, as you would to manually in a |
|
5b54f413d132
patch 8.2.4136: Vim9: the "autoload" argument of ":vim9script" is not useful
Bram Moolenaar <Bram@vim.org>
parents:
27162
diff
changeset
|
1896 legacy autoload script. Thus the exported function can be found with |
|
5b54f413d132
patch 8.2.4136: Vim9: the "autoload" argument of ":vim9script" is not useful
Bram Moolenaar <Bram@vim.org>
parents:
27162
diff
changeset
|
1897 "for#search#Stuff", but you would normally use `import autoload` and not |
| 28141 | 1898 use the prefix (which has the side effect of loading the autoload script |
| 1899 when compiling a function that encounters this name). | |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1900 |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1901 You can split up the functionality and import other scripts from the |
|
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1902 autoload script as you like. This way you can share code between plugins. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1903 |
| 28379 | 1904 Searching for the autoload script in all entries in 'runtimepath' can be a bit |
| 1905 slow. If the plugin knows where the script is located, quite often a relative | |
| 1906 path can be used. This avoids the search and should be quite a bit faster. | |
| 1907 Another advantage is that the script name does not need to be unique. An | |
| 1908 absolute path is also possible. Examples: > | |
| 1909 import autoload '../lib/implement.vim' | |
| 1910 import autoload MyScriptsDir .. '/lib/implement.vim' | |
| 1911 | |
| 27162 | 1912 For defining a mapping that uses the imported autoload script the special key |
| 1913 |<ScriptCmd>| is useful. It allows for a command in a mapping to use the | |
| 1914 script context of where the mapping was defined. | |
| 1915 | |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
1916 When compiling a `:def` function and a function in an autoload script is |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
1917 encountered, the script is not loaded until the `:def` function is called. |
|
27043
15f40772e10a
patch 8.2.4050: Vim9: need to prefix every item in an autoload script
Bram Moolenaar <Bram@vim.org>
parents:
27036
diff
changeset
|
1918 This also means you get any errors only at runtime, since the argument and |
| 28141 | 1919 return types are not known yet. If you would use the name with '#' characters |
| 1920 then the autoload script IS loaded. | |
| 1921 | |
| 1922 Be careful to not refer to an item in an autoload script that does trigger | |
| 1923 loading it unintentionally. For example, when setting an option that takes a | |
| 1924 function name, make sure to use a string, not a function reference: > | |
| 1925 import autoload 'qftf.vim' | |
| 1926 &quickfixtextfunc = 'qftf.Func' # autoload script NOT loaded | |
| 1927 &quickfixtextfunc = qftf.Func # autoload script IS loaded | |
| 1928 On the other hand, it can be useful to load the script early, at a time when | |
| 1929 any errors should be given. | |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
1930 |
| 27162 | 1931 For testing the |test_override()| function can be used to have the |
| 1932 `import autoload` load the script right away, so that the items and types can | |
| 1933 be checked without waiting for them to be actually used: > | |
| 1934 test_override('autoload', 1) | |
| 1935 Reset it later with: > | |
| 1936 test_override('autoload', 0) | |
| 1937 Or: > | |
| 1938 test_override('ALL', 0) | |
| 1939 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1940 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1941 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1942 |
| 22328 | 1943 6. Future work: classes *vim9-classes* |
| 1944 | |
| 1945 Above "class" was mentioned a few times, but it has not been implemented yet. | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
1946 Most of Vim9 script can be created without this functionality, and since |
| 22328 | 1947 implementing classes is going to be a lot of work, it is left for the future. |
| 1948 For now we'll just make sure classes can be added later. | |
| 1949 | |
| 1950 Thoughts: | |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1951 - `class` / `endclass`, the whole class must be in one file |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1952 - Class names are always CamelCase (to avoid a name clash with builtin types) |
| 31139 | 1953 - A single constructor called "constructor" (similar to TypeScript) |
| 1954 - Single inheritance: `class ThisClass extends BaseClass` | |
| 1955 - `interface` / `endinterface` (looks like a class without any implementation) | |
| 1956 - Explicit declaration that the class supports an interface, so that type | |
| 1957 checking works properly: | |
| 1958 `class SomeClass implements SomeInterface, OtherInterface` | |
| 1959 - `abstract class` (class with incomplete implementation) - not really needed? | |
| 1960 - Class (static) methods and Object methods: syntax to be defined. | |
| 1961 - Class (static) members and Object members: syntax to be defined. | |
| 1962 - Access control: private / protected / shared / public ? Keep it simple. | |
| 1963 - Access object members with `this.member` ? | |
| 22328 | 1964 - Generics for class: `class <Tkey, Tentry>` |
| 1965 - Generics for function: `def <Tkey> GetLast(key: Tkey)` | |
| 31139 | 1966 - Method overloading (two methods with the same name but different argument |
| 1967 types): Most likely not | |
| 1968 - Mixins: not sure if that is useful, leave out for simplicity. | |
| 22328 | 1969 |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1970 Again, much of this is from TypeScript with a slightly different syntax. |
| 22328 | 1971 |
| 1972 Some things that look like good additions: | |
| 1973 - Use a class as an interface (like Dart) | |
| 1974 - Extend a class with methods, using an import (like Dart) | |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1975 - Mixins |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1976 - For testing: Mock mechanism |
| 22328 | 1977 |
| 1978 An important class that will be provided is "Promise". Since Vim is single | |
| 1979 threaded, connecting asynchronous operations is a natural way of allowing | |
| 1980 plugins to do their work without blocking the user. It's a uniform way to | |
| 1981 invoke callbacks and handle timeouts and errors. | |
| 1982 | |
| 28010 | 1983 Some commands have already been reserved: |
| 1984 *:class* | |
| 1985 *:endclass* | |
| 1986 *:abstract* | |
| 1987 *:enum* | |
| 1988 *:endenum* | |
| 1989 *:interface* | |
| 1990 *:endinterface* | |
| 1991 *:static* | |
| 1992 *:type* | |
| 1993 | |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1994 Some examples: > |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1995 |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1996 abstract class Person |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1997 static const prefix = 'xxx' |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1998 var name: string |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
1999 |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2000 def constructor(name: string) |
| 25402 | 2001 this.name = name |
|
24888
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2002 enddef |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2003 |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2004 def display(): void |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2005 echo name |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2006 enddef |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2007 |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2008 abstract def find(string): Person |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2009 endclass |
|
b6ac4ed5e2d2
patch 8.2.2982: Vim9: future commands are not reserved yet
Bram Moolenaar <Bram@vim.org>
parents:
24751
diff
changeset
|
2010 |
| 22328 | 2011 ============================================================================== |
| 2012 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2013 9. Rationale *vim9-rationale* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2014 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2015 The :def command ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2016 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2017 Plugin writers have asked for much faster Vim script. Investigations have |
| 19303 | 2018 shown that keeping the existing semantics of function calls make this close to |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2019 impossible, because of the overhead involved with calling a function, setting |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2020 up the local function scope and executing lines. There are many details that |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2021 need to be handled, such as error messages and exceptions. The need to create |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2022 a dictionary for a: and l: scopes, the a:000 list and several others add too |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2023 much overhead that cannot be avoided. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2024 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2025 Therefore the `:def` method to define a new-style function had to be added, |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2026 which allows for a function with different semantics. Most things still work |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2027 as before, but some parts do not. A new way to define a function was |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2028 considered the best way to separate the legacy style code from Vim9 style code. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2029 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2030 Using "def" to define a function comes from Python. Other languages use |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2031 "function" which clashes with legacy Vim script. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2032 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2033 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2034 Type checking ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2035 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2036 When compiling lines of Vim commands into instructions as much as possible |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2037 should be done at compile time. Postponing it to runtime makes the execution |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2038 slower and means mistakes are found only later. For example, when |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2039 encountering the "+" character and compiling this into a generic add |
| 23666 | 2040 instruction, at runtime the instruction would have to inspect the type of the |
| 2041 arguments and decide what kind of addition to do. And when the type is | |
| 2042 dictionary throw an error. If the types are known to be numbers then an "add | |
| 2043 number" instruction can be used, which is faster. The error can be given at | |
| 2044 compile time, no error handling is needed at runtime, since adding two numbers | |
| 2045 cannot fail. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2046 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2047 The syntax for types, using <type> for compound types, is similar to Java. It |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2048 is easy to understand and widely used. The type names are what were used in |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2049 Vim before, with some additions such as "void" and "bool". |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2050 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2051 |
| 22328 | 2052 Removing clutter and weirdness ~ |
| 20856 | 2053 |
| 22328 | 2054 Once decided that `:def` functions have different syntax than legacy functions, |
| 2055 we are free to add improvements to make the code more familiar for users who | |
| 2056 know popular programming languages. In other words: remove weird things that | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2057 only Vim does. |
| 22328 | 2058 |
| 2059 We can also remove clutter, mainly things that were done to make Vim script | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2060 backwards compatible with the good old Vi commands. |
| 20856 | 2061 |
| 22328 | 2062 Examples: |
| 29104 | 2063 - Drop `:call` for calling a function and `:eval` for evaluating an |
| 2064 expression. | |
| 22328 | 2065 - Drop using a leading backslash for line continuation, automatically figure |
| 2066 out where an expression ends. | |
| 20856 | 2067 |
| 22328 | 2068 However, this does require that some things need to change: |
| 2069 - Comments start with # instead of ", to avoid confusing them with strings. | |
| 29104 | 2070 This is good anyway, it is also used by several popular languages. |
| 22328 | 2071 - Ex command ranges need to be prefixed with a colon, to avoid confusion with |
| 2072 expressions (single quote can be a string or a mark, "/" can be divide or a | |
| 2073 search command, etc.). | |
| 2074 | |
| 2075 Goal is to limit the differences. A good criteria is that when the old syntax | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2076 is accidentally used you are very likely to get an error message. |
| 20856 | 2077 |
| 2078 | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2079 Syntax and semantics from popular languages ~ |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2080 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2081 Script writers have complained that the Vim script syntax is unexpectedly |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2082 different from what they are used to. To reduce this complaint popular |
| 20856 | 2083 languages are used as an example. At the same time, we do not want to abandon |
| 2084 the well-known parts of legacy Vim script. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2085 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2086 For many things TypeScript is followed. It's a recent language that is |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2087 gaining popularity and has similarities with Vim script. It also has a |
| 22328 | 2088 mix of static typing (a variable always has a known value type) and dynamic |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2089 typing (a variable can have different types, this changes at runtime). Since |
| 22328 | 2090 legacy Vim script is dynamically typed and a lot of existing functionality |
| 2091 (esp. builtin functions) depends on that, while static typing allows for much | |
| 2092 faster execution, we need to have this mix in Vim9 script. | |
| 2093 | |
| 22171 | 2094 There is no intention to completely match TypeScript syntax and semantics. We |
| 2095 just want to take those parts that we can use for Vim and we expect Vim users | |
| 22328 | 2096 will be happy with. TypeScript is a complex language with its own history, |
| 2097 advantages and disadvantages. To get an idea of the disadvantages read the | |
| 2098 book: "JavaScript: The Good Parts". Or find the article "TypeScript: the good | |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2099 parts" and read the "Things to avoid" section. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2100 |
| 22328 | 2101 People familiar with other languages (Java, Python, etc.) will also find |
| 2102 things in TypeScript that they do not like or do not understand. We'll try to | |
| 2103 avoid those things. | |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2104 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2105 Specific items from TypeScript we avoid: |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2106 - Overloading "+", using it both for addition and string concatenation. This |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2107 goes against legacy Vim script and often leads to mistakes. For that reason |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2108 we will keep using ".." for string concatenation. Lua also uses ".." this |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2109 way. And it allows for conversion to string for more values. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2110 - TypeScript can use an expression like "99 || 'yes'" in a condition, but |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2111 cannot assign the value to a boolean. That is inconsistent and can be |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2112 annoying. Vim recognizes an expression with && or || and allows using the |
|
26755
ddaea8dcaff5
patch 8.2.3906: Vim9 help still contains "under development" warnings
Bram Moolenaar <Bram@vim.org>
parents:
26745
diff
changeset
|
2113 result as a bool. The |falsy-operator| was added for the mechanism to use a |
|
ddaea8dcaff5
patch 8.2.3906: Vim9 help still contains "under development" warnings
Bram Moolenaar <Bram@vim.org>
parents:
26745
diff
changeset
|
2114 default value. |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2115 - TypeScript considers an empty string as Falsy, but an empty list or dict as |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2116 Truthy. That is inconsistent. In Vim an empty list and dict are also |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2117 Falsy. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2118 - TypeScript has various "Readonly" types, which have limited usefulness, |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2119 since a type cast can remove the immutable nature. Vim locks the value, |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
2120 which is more flexible, but is only checked at runtime. |
| 27459 | 2121 - TypeScript has a complicated "import" statement that does not match how the |
| 2122 Vim import mechanism works. A much simpler mechanism is used instead, which | |
| 2123 matches that the imported script is only sourced once. | |
| 22171 | 2124 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2125 |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2126 Declarations ~ |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2127 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2128 Legacy Vim script uses `:let` for every assignment, while in Vim9 declarations |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2129 are used. That is different, thus it's good to use a different command: |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2130 `:var`. This is used in many languages. The semantics might be slightly |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2131 different, but it's easily recognized as a declaration. |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2132 |
| 23047 | 2133 Using `:const` for constants is common, but the semantics varies. Some |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2134 languages only make the variable immutable, others also make the value |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2135 immutable. Since "final" is well known from Java for only making the variable |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2136 immutable we decided to use that. And then `:const` can be used for making |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2137 both immutable. This was also used in legacy Vim script and the meaning is |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2138 almost the same. |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2139 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2140 What we end up with is very similar to Dart: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2141 :var name # mutable variable and value |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2142 :final name # immutable variable, mutable value |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2143 :const name # immutable variable and value |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2144 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2145 Since legacy and Vim9 script will be mixed and global variables will be |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2146 shared, optional type checking is desirable. Also, type inference will avoid |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2147 the need for specifying the type in many cases. The TypeScript syntax fits |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2148 best for adding types to declarations: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2149 var name: string # string type is specified |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2150 ... |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2151 name = 'John' |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2152 const greeting = 'hello' # string type is inferred |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2153 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2154 This is how we put types in a declaration: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2155 var mylist: list<string> |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2156 final mylist: list<string> = ['foo'] |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2157 def Func(arg1: number, arg2: string): bool |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2158 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2159 Two alternatives were considered: |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2160 1. Put the type before the name, like Dart: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2161 var list<string> mylist |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2162 final list<string> mylist = ['foo'] |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2163 def Func(number arg1, string arg2) bool |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2164 2. Put the type after the variable name, but do not use a colon, like Go: > |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2165 var mylist list<string> |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2166 final mylist list<string> = ['foo'] |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2167 def Func(arg1 number, arg2 string) bool |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2168 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2169 The first is more familiar for anyone used to C or Java. The second one |
| 22565 | 2170 doesn't really have an advantage over the first, so let's discard the second. |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2171 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2172 Since we use type inference the type can be left out when it can be inferred |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2173 from the value. This means that after `var` we don't know if a type or a name |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2174 follows. That makes parsing harder, not only for Vim but also for humans. |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2175 Also, it will not be allowed to use a variable name that could be a type name, |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2176 using `var string string` is too confusing. |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2177 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2178 The chosen syntax, using a colon to separate the name from the type, adds |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2179 punctuation, but it actually makes it easier to recognize the parts of a |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2180 declaration. |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2181 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2182 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2183 Expressions ~ |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2184 |
| 22565 | 2185 Expression evaluation was already close to what other languages are doing. |
| 2186 Some details are unexpected and can be improved. For example a boolean | |
| 2187 condition would accept a string, convert it to a number and check if the | |
| 2188 number is non-zero. This is unexpected and often leads to mistakes, since | |
| 2189 text not starting with a number would be converted to zero, which is | |
| 22723 | 2190 considered false. Thus using a string for a condition would often not give an |
| 2191 error and be considered false. That is confusing. | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2192 |
| 23047 | 2193 In Vim9 type checking is stricter to avoid mistakes. Where a condition is |
| 22565 | 2194 used, e.g. with the `:if` command and the `||` operator, only boolean-like |
| 2195 values are accepted: | |
| 2196 true: `true`, `v:true`, `1`, `0 < 9` | |
| 2197 false: `false`, `v:false`, `0`, `0 > 9` | |
| 2198 Note that the number zero is false and the number one is true. This is more | |
| 22723 | 2199 permissive than most other languages. It was done because many builtin |
| 29104 | 2200 functions return these values, and changing that causes more problems than it |
| 2201 solves. After using this for a while it turned out to work well. | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2202 |
| 22565 | 2203 If you have any type of value and want to use it as a boolean, use the `!!` |
| 2204 operator: | |
| 29104 | 2205 true: `!!'text'` `!![99]` `!!{'x': 1}` `!!99` |
| 2206 false: `!!''` `!![]` `!!{}` | |
| 22565 | 2207 |
| 2208 From a language like JavaScript we have this handy construct: > | |
| 2209 GetName() || 'unknown' | |
| 2210 However, this conflicts with only allowing a boolean for a condition. | |
| 2211 Therefore the "??" operator was added: > | |
| 2212 GetName() ?? 'unknown' | |
| 2213 Here you can explicitly express your intention to use the value as-is and not | |
| 2214 result in a boolean. This is called the |falsy-operator|. | |
|
22391
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2215 |
|
a9fb7efa31d6
patch 8.2.1744: Vim9: using ":const!" is weird
Bram Moolenaar <Bram@vim.org>
parents:
22328
diff
changeset
|
2216 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2217 Import and Export ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2218 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2219 A problem of legacy Vim script is that by default all functions and variables |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2220 are global. It is possible to make them script-local, but then they are not |
| 22171 | 2221 available in other scripts. This defies the concept of a package that only |
| 2222 exports selected items and keeps the rest local. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2223 |
| 21825 | 2224 In Vim9 script a mechanism very similar to the JavaScript import and export |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2225 mechanism is supported. It is a variant to the existing `:source` command |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2226 that works like one would expect: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2227 - Instead of making everything global by default, everything is script-local, |
| 29104 | 2228 some of these are exported. |
| 22171 | 2229 - When importing a script the symbols that are imported are explicitly listed, |
| 2230 avoiding name conflicts and failures if functionality is added later. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2231 - The mechanism allows for writing a big, long script with a very clear API: |
| 29104 | 2232 the exported functions, variables and classes. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2233 - By using relative paths loading can be much faster for an import inside of a |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2234 package, no need to search many directories. |
| 29104 | 2235 - Once an import has been used, its items are cached and loading it again is |
| 2236 not needed. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2237 - The Vim-specific use of "s:" to make things script-local can be dropped. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2238 |
| 29104 | 2239 When sourcing a Vim9 script (from a Vim9 or legacy script), only the items |
| 2240 defined globally can be used, not the exported items. Alternatives | |
| 2241 considered: | |
| 20856 | 2242 - All the exported items become available as script-local items. This makes |
| 22171 | 2243 it uncontrollable what items get defined and likely soon leads to trouble. |
| 20856 | 2244 - Use the exported items and make them global. Disadvantage is that it's then |
| 2245 not possible to avoid name clashes in the global namespace. | |
| 2246 - Completely disallow sourcing a Vim9 script, require using `:import`. That | |
| 2247 makes it difficult to use scripts for testing, or sourcing them from the | |
| 2248 command line to try them out. | |
| 29104 | 2249 Note that you CAN also use `:import` in legacy Vim script, see above. |
| 20856 | 2250 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2251 |
| 22328 | 2252 Compiling functions early ~ |
| 2253 | |
| 2254 Functions are compiled when called or when `:defcompile` is used. Why not | |
| 2255 compile them early, so that syntax and type errors are reported early? | |
| 2256 | |
| 2257 The functions can't be compiled right away when encountered, because there may | |
| 2258 be forward references to functions defined later. Consider defining functions | |
| 2259 A, B and C, where A calls B, B calls C, and C calls A again. It's impossible | |
| 2260 to reorder the functions to avoid forward references. | |
| 2261 | |
| 2262 An alternative would be to first scan through the file to locate items and | |
| 2263 figure out their type, so that forward references are found, and only then | |
| 2264 execute the script and compile the functions. This means the script has to be | |
| 2265 parsed twice, which is slower, and some conditions at the script level, such | |
| 2266 as checking if a feature is supported, are hard to use. An attempt was made | |
| 29104 | 2267 to see if it works, but it turned out to be impossible to make work well. |
| 22328 | 2268 |
| 2269 It would be possible to compile all the functions at the end of the script. | |
| 2270 The drawback is that if a function never gets called, the overhead of | |
| 2271 compiling it counts anyway. Since startup speed is very important, in most | |
| 2272 cases it's better to do it later and accept that syntax and type errors are | |
| 2273 only reported then. In case these errors should be found early, e.g. when | |
| 29104 | 2274 testing, a `:defcompile` command at the end of the script will help out. |
| 22328 | 2275 |
| 2276 | |
| 29104 | 2277 Why not use an existing embedded language? ~ |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2278 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2279 Vim supports interfaces to Perl, Python, Lua, Tcl and a few others. But |
| 22328 | 2280 these interfaces have never become widely used, for various reasons. When |
| 2281 Vim9 was designed a decision was made to make these interfaces lower priority | |
| 2282 and concentrate on Vim script. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2283 |
| 22328 | 2284 Still, plugin writers may find other languages more familiar, want to use |
| 2285 existing libraries or see a performance benefit. We encourage plugin authors | |
| 29104 | 2286 to write code in any language and run it as an external process, using jobs |
| 2287 and channels. We can try to make this easier somehow. | |
| 22328 | 2288 |
| 2289 Using an external tool also has disadvantages. An alternative is to convert | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2290 the tool into Vim script. For that to be possible without too much |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2291 translation, and keeping the code fast at the same time, the constructs of the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2292 tool need to be supported. Since most languages support classes the lack of |
| 22171 | 2293 support for classes in Vim is then a problem. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2294 |
| 22328 | 2295 |
| 2296 Classes ~ | |
| 2297 | |
| 2298 Vim supports a kind-of object oriented programming by adding methods to a | |
| 2299 dictionary. With some care this can be made to work, but it does not look | |
| 2300 like real classes. On top of that, it's quite slow, because of the use of | |
| 2301 dictionaries. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2302 |
| 29121 | 2303 It would be good to support real classes, and this is planned for a later |
| 29104 | 2304 version. The support is a "minimal common functionality" of class support in |
| 2305 most languages. It will work much like Java, which is the most popular | |
| 2306 programming language. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2307 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2308 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2309 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2310 vim:tw=78:ts=8:noet:ft=help:norl: |