Mercurial > vim
annotate runtime/doc/vim9.txt @ 22328:75ff30a78189
Update runtime files.
Commit: https://github.com/vim/vim/commit/1d59aa1fdfb191d9872ff87eb94652acd374b293
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat Sep 19 18:50:13 2020 +0200
Update runtime files.
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sat, 19 Sep 2020 19:00:04 +0200 |
| parents | eb1f5f618c75 |
| children | a9fb7efa31d6 |
| rev | line source |
|---|---|
| 22328 | 1 *vim9.txt* For Vim version 8.2. Last change: 2020 Sep 17 |
|
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 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
7 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
8 |
| 20241 | 9 Vim9 script commands and expressions. *vim9* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
10 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
11 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
|
12 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
|
13 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
14 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
15 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
16 |
| 21676 | 17 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
|
18 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
|
19 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
|
20 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
|
21 5. Namespace, Import and Export |vim9script| |
| 22328 | 22 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
|
23 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
24 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
|
25 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
26 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
27 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
28 1. What is Vim9 script? *vim9-script* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
29 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
30 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
31 |
| 20241 | 32 Vim script has been growing over time, while preserving backwards |
| 33 compatibility. That means bad choices from the past often can't be changed | |
| 20965 | 34 and compatibility with Vi restricts possible solutions. Execution is quite |
| 20241 | 35 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
|
36 |
| 20241 | 37 The main goal of Vim9 script is to drastically improve performance. This is |
| 38 accomplished by compiling commands into instructions that can be efficiently | |
| 39 executed. An increase in execution speed of 10 to 100 times can be expected. | |
| 40 | |
| 41 A secondary goal is to avoid Vim-specific constructs and get closer to | |
| 42 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
|
43 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
44 The performance improvements can only be achieved by not being 100% backwards |
| 20552 | 45 compatible. For example, making function arguments available in the |
| 46 "a:" dictionary adds quite a lot of overhead. In a Vim9 function this | |
| 47 dictionary is not available. Other differences are more subtle, such as how | |
| 48 errors are handled. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
49 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
50 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
|
51 - 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
|
52 - a script file where the first command is `vim9script` |
| 22328 | 53 - an autocommand defined in the context of the above |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
54 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
55 When using `:function` in a Vim9 script file the legacy syntax is used. |
| 20241 | 56 However, this can be confusing and is therefore discouraged. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
57 |
| 20241 | 58 Vim9 script and legacy Vim script can be mixed. There is no requirement to |
| 22328 | 59 rewrite old scripts, they keep working as before. You may want to use a few |
| 60 `: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
|
61 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
62 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
63 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
64 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
|
65 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
66 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
67 |
|
20023
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
68 Comments starting with # ~ |
|
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
69 |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
70 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
|
71 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
|
72 # declarations |
| 20965 | 73 let 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
|
74 |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
75 The reason is that a double quote can also be the start of a string. In many |
| 21825 | 76 places, especially halfway through an expression with a line break, it's hard |
| 77 to tell what the meaning is, since both a string and a comment can be followed | |
| 78 by arbitrary text. To avoid confusion only # comments are recognized. This | |
| 79 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
|
80 |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
81 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
|
82 `:number` for that. > |
|
21516
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
83 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
|
84 |
|
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
85 To improve readability there must be a space between a command and the # |
| 20115 | 86 that starts a comment. Note that #{ is the start of a dictionary, therefore |
|
21516
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
87 it does not start a comment. |
| 20115 | 88 |
|
20023
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
89 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
90 Vim9 functions ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
91 |
| 20241 | 92 A function defined with `:def` is compiled. Execution is many times faster, |
| 93 often 10x to 100x times. | |
| 94 | |
| 20552 | 95 Many errors are already found when compiling, before the function is executed. |
| 20241 | 96 The syntax is strict, to enforce code that is easy to read and understand. |
| 97 | |
| 21991 | 98 Compilation is done when: |
| 99 - the function is first called | |
| 100 - when the `:defcompile` command is encountered in the script where the | |
| 101 function was defined | |
| 102 - `:disassemble` is used for the function. | |
| 103 - a function that is compiled calls the function or uses it as a function | |
| 104 reference | |
| 20552 | 105 |
| 106 `:def` has no options like `:function` does: "range", "abort", "dict" or | |
| 107 "closure". A `:def` function always aborts on an error, does not get a range | |
| 108 passed and cannot be a "dict" function. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
109 |
| 20241 | 110 The argument types and return type need to be specified. The "any" type can |
| 111 be used, type checking will then be done at runtime, like with legacy | |
| 112 functions. | |
| 113 | |
| 21825 | 114 Arguments are accessed by name, without "a:", just like any other language. |
| 115 There is no "a:" dictionary or "a:000" list. | |
| 20241 | 116 |
| 117 Variable arguments are defined as the last argument, with a name and have a | |
| 21825 | 118 list type, similar to TypeScript. For example, a list of numbers: > |
| 22171 | 119 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
|
120 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
|
121 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
122 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
123 |
| 20241 | 124 Functions and variables are script-local by default ~ |
| 20856 | 125 *vim9-scopes* |
| 20115 | 126 When using `:function` or `:def` to specify a new function at the script level |
| 127 in a Vim9 script, the function is local to the script, as if "s:" was | |
|
21550
b0b57d91671c
patch 8.2.1325: Vim9: using Vim9 script for autaload not tested
Bram Moolenaar <Bram@vim.org>
parents:
21516
diff
changeset
|
128 prefixed. Using the "s:" prefix is optional. To define or use a global |
| 21676 | 129 function or variable the "g:" prefix should be used. For functions in an |
|
21550
b0b57d91671c
patch 8.2.1325: Vim9: using Vim9 script for autaload not tested
Bram Moolenaar <Bram@vim.org>
parents:
21516
diff
changeset
|
130 autoload script the "name#" prefix is sufficient. > |
|
b0b57d91671c
patch 8.2.1325: Vim9: using Vim9 script for autaload not tested
Bram Moolenaar <Bram@vim.org>
parents:
21516
diff
changeset
|
131 def ThisFunction() # script-local |
|
b0b57d91671c
patch 8.2.1325: Vim9: using Vim9 script for autaload not tested
Bram Moolenaar <Bram@vim.org>
parents:
21516
diff
changeset
|
132 def s:ThisFunction() # script-local |
| 22171 | 133 def g:ThatFunction() # global |
| 134 def ThatFunction() # global if no local ThatFunction() | |
|
21550
b0b57d91671c
patch 8.2.1325: Vim9: using Vim9 script for autaload not tested
Bram Moolenaar <Bram@vim.org>
parents:
21516
diff
changeset
|
135 def scriptname#function() # autoload |
| 20115 | 136 |
| 137 When using `:function` or `:def` to specify a new function inside a function, | |
| 138 the function is local to the function. It is not possible to define a | |
| 20241 | 139 script-local function inside a function. It is possible to define a global |
| 140 function, using the "g:" prefix. | |
| 20115 | 141 |
| 142 When referring to a function and no "s:" or "g:" prefix is used, Vim will | |
| 21676 | 143 prefer using a local function (in the function scope, script scope or |
| 144 imported) before looking for a global function. | |
| 20552 | 145 In all cases the function must be defined before used. That is when it is |
| 146 first called or when `:defcompile` causes the call to be compiled. | |
| 20241 | 147 |
| 21676 | 148 The result is that functions and variables without a namespace can usually be |
| 20241 | 149 found in the script, either defined there or imported. Global functions and |
| 21676 | 150 variables could be defined anywhere (good luck finding out where!). |
| 20115 | 151 |
| 21825 | 152 Global functions can still be defined and deleted at nearly any time. In |
| 20317 | 153 Vim9 script script-local functions are defined once when the script is sourced |
| 20552 | 154 and cannot be deleted or replaced. |
| 20115 | 155 |
| 156 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
157 Variable declarations with :let and :const ~ |
| 20856 | 158 *vim9-declaration* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
159 Local variables need to be declared with `:let`. Local constants need to be |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
160 declared with `:const`. We refer to both as "variables". |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
161 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
162 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
|
163 vim9script |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
164 let script_var = 123 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
165 def SomeFunc() |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
166 let func_var = script_var |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
167 if cond |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
168 let block_var = func_var |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
169 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
170 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
171 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
|
172 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
|
173 if cond |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
174 let inner = 5 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
175 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
176 let inner = 0 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
177 endif |
| 22171 | 178 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
|
179 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
180 The declaration must be done earlier: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
181 let inner: number |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
182 if cond |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
183 inner = 5 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
184 else |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
185 inner = 0 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
186 endif |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
187 echo inner |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
188 |
| 20552 | 189 To intentionally avoid a variable being available later, a block can be used: |
| 190 > | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
191 { |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
192 let temp = 'temp' |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
193 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
194 } |
| 22171 | 195 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
|
196 |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
197 Declaring a variable with a type but without an initializer will initialize to |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
198 zero, false or empty. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
199 |
| 19303 | 200 An existing variable cannot be assigned to with `:let`, since that implies a |
| 21499 | 201 declaration. Global, window, tab, buffer and Vim variables can only be used |
|
21584
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
202 without `:let`, because they are not really declared, they can also be deleted |
|
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
203 with `:unlet`. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
204 |
| 21676 | 205 Variables and functions cannot shadow previously defined or imported variables |
| 206 and functions. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
207 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
|
208 |
| 20241 | 209 Global variables and user defined functions must be prefixed with "g:", also |
| 210 at the script level. > | |
| 19968 | 211 vim9script |
| 212 let script_local = 'text' | |
| 21499 | 213 g:global = 'value' |
| 20241 | 214 let Funcref = g:ThatFunction |
| 19968 | 215 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
216 Since "&opt = value" is now assigning a value to option "opt", ":&" cannot be |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
217 used to repeat a `:substitute` command. |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
218 *vim9-const* |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
219 In legacy Vim script "const list = []" would make the variable "list" |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
220 immutable and also the value. Thus you cannot add items to the list. This |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
221 differs from what many languages do. Vim9 script does it like TypeScript: only |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
222 "list" is immutable, the value can be changed. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
223 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
224 One can use `:const!` to make both the variable and the value immutable. Use |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
225 this for composite structures that you want to make sure will not be modified. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
226 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
227 How this works: > |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
228 vim9script |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
229 const list = [1, 2] |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
230 list = [3, 4] # Error! |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
231 list[0] = 2 # OK |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
232 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
233 const! LIST = [1, 2] |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
234 LIST = [3, 4] # Error! |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
235 LIST[0] = 2 # Error! |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
236 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
|
237 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
238 The constant only applies to the value itself, not what it refers to. > |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
239 cont females = ["Mary"] |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
240 const! NAMES = [["John", "Peter"], females] |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
241 NAMES[0] = ["Jack"] # Error! |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
242 NAMES[0][0] = ["Jack"] # Error! |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
243 NAMES[1] = ["Emma"] # Error! |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
244 Names[1][0] = "Emma" # OK, now females[0] == "Emma" |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
245 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
246 Rationale: TypeScript has no way to make the value immutable. One can use |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
247 immutable types, but that quickly gets complicated for nested values. And |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
248 with a type cast the value can be made mutable again, which means there is no |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
249 guarantee the value won't change. Vim supports immutable values, in legacy |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
250 script this was done with `:lockvar`. But that is an extra statement and also |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
251 applies to nested values. Therefore the solution to use `:const!`. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
252 |
| 21499 | 253 *E1092* |
| 254 Declaring more than one variable at a time, using the unpack notation, is | |
| 255 currently not supported: > | |
| 256 let [v1, v2] = GetValues() # Error! | |
| 257 That is because the type needs to be inferred from the list item type, which | |
| 258 isn't that easy. | |
| 259 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
260 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
261 Omitting :call and :eval ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
262 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
263 Functions can be called without `:call`: > |
| 22171 | 264 writefile(lines, 'file') |
| 19303 | 265 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
|
266 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
267 A method call without `eval` is possible, so long as the start is an |
|
21516
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
268 identifier or can't be an Ex command. Examples: > |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
269 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
|
270 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
|
271 [1, 2, 3]->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
272 #{a: 1, b: 2}->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
273 {'a': 1, 'b': 2}->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
274 "foobar"->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
275 ("foobar")->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
276 'foobar'->Process() |
|
c7b2ce90c2de
patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit
Bram Moolenaar <Bram@vim.org>
parents:
21499
diff
changeset
|
277 ('foobar')->Process() |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
278 |
| 21825 | 279 In the rare case there is ambiguity between a function name and an Ex command, |
| 21676 | 280 prepend ":" to make clear you want to use the Ex command. For example, there |
| 281 is both the `:substitute` command and the `substitute()` function. When the | |
| 282 line starts with `substitute(` this will use the function. Prepend a colon to | |
| 283 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
|
284 :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
|
285 |
|
19556
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
286 Note that while variables need to be defined before they can be used, |
| 21825 | 287 functions can be called before being defined. This is required to allow |
| 288 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
|
289 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
|
290 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
|
291 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
292 |
| 19968 | 293 Omitting function() ~ |
| 294 | |
| 295 A user defined function can be used as a function reference in an expression | |
| 296 without `function()`. The argument types and return type will then be checked. | |
| 297 The function must already have been defined. > | |
| 298 | |
| 299 let Funcref = MyFunction | |
| 300 | |
| 301 When using `function()` the resulting type is "func", a function with any | |
| 302 number of arguments and any return type. The function can be defined later. | |
| 303 | |
| 304 | |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
305 Automatic line continuation ~ |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
306 |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
307 In many cases it is obvious that an expression continues on the next line. In |
| 21676 | 308 those cases there is no need to prefix the line with a backslash |
| 309 |line-continuation|. For example, when a list spans multiple lines: > | |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
310 let mylist = [ |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
311 'one', |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
312 'two', |
|
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
313 ] |
|
20011
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
314 And when a dict spans multiple lines: > |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
315 let mydict = #{ |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
316 one: 1, |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
317 two: 2, |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
318 } |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
319 Function call: > |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
320 let result = Func( |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
321 arg1, |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
322 arg2 |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
323 ) |
|
628011800942
patch 8.2.0561: Vim9: cannot split function call in multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
19999
diff
changeset
|
324 |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
325 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
|
326 possible just before or after the operator. For example: > |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
327 let text = lead |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
328 .. middle |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
329 .. end |
|
20013
bf377a9ffccb
patch 8.2.0562: Vim9: cannot split an expression into multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
20011
diff
changeset
|
330 let total = start + |
|
bf377a9ffccb
patch 8.2.0562: Vim9: cannot split an expression into multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
20011
diff
changeset
|
331 end - |
|
bf377a9ffccb
patch 8.2.0562: Vim9: cannot split an expression into multiple lines
Bram Moolenaar <Bram@vim.org>
parents:
20011
diff
changeset
|
332 correction |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
333 let result = positive |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
334 ? 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
|
335 : 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
|
336 |
| 21499 | 337 For a method call using "->" and a member using a dot, a line break is allowed |
| 338 before it: > | |
| 20965 | 339 let result = GetBuilder() |
| 340 ->BuilderSetWidth(333) | |
| 341 ->BuilderSetHeight(777) | |
| 342 ->BuilderBuild() | |
| 21499 | 343 let result = MyDict |
| 344 .member | |
| 20965 | 345 |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
346 < *E1050* |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
347 To make it possible for the operator at the start of the line to be |
| 21250 | 348 recognized, it is required to put a colon before a range. This will add |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
349 "start" and print: > |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
350 let result = start |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
351 + print |
| 21250 | 352 Like this: > |
| 353 let result = start + print | |
| 354 | |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
355 This will assign "start" and print a line: > |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
356 let result = start |
|
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
357 :+ print |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
358 |
|
20015
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
359 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
|
360 arguments: > |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
361 def MyFunc( |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
362 text: string, |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
363 separator = '-' |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
364 ): string |
|
c001ee73519a
patch 8.2.0563: Vim9: cannot split a function line
Bram Moolenaar <Bram@vim.org>
parents:
20013
diff
changeset
|
365 |
| 21250 | 366 Notes: |
| 367 - "enddef" cannot be used at the start of a continuation line, it ends the | |
| 368 current function. | |
| 369 - No line break is allowed in the LHS of an assignment. Specifically when | |
| 370 unpacking a list |:let-unpack|. This is OK: > | |
| 22171 | 371 [var1, var2] = |
| 21250 | 372 Func() |
| 373 < This does not work: > | |
| 22171 | 374 [var1, |
| 21250 | 375 var2] = |
| 376 Func() | |
| 377 - No line break is allowed in between arguments of an `:echo`, `:execute` and | |
| 378 similar commands. This is OK: > | |
| 22171 | 379 echo [1, |
| 21250 | 380 2] [3, |
| 381 4] | |
| 382 < This does not work: > | |
| 22171 | 383 echo [1, 2] |
| 21250 | 384 [3, 4] |
| 385 - No line break is allowed in the arguments of a lambda, between the "{" and | |
| 386 "->". This is OK: > | |
| 22171 | 387 filter(list, {k, v -> |
| 21250 | 388 v > 0}) |
| 389 < This does not work: > | |
| 22171 | 390 filter(list, {k, |
| 21250 | 391 v -> v > 0}) |
|
20982
bb49b5090a9c
patch 8.2.1042: Vim9: cannot put an operator on the next line
Bram Moolenaar <Bram@vim.org>
parents:
20965
diff
changeset
|
392 |
|
19999
844c7646f61b
patch 8.2.0555: Vim9: line continuation is not always needed
Bram Moolenaar <Bram@vim.org>
parents:
19968
diff
changeset
|
393 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
394 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
|
395 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
396 |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
|
397 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
398 |
|
21584
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
399 No :xit, :t, :append, :change or :insert ~ |
| 19303 | 400 |
|
21584
d0c76ce48326
patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error
Bram Moolenaar <Bram@vim.org>
parents:
21550
diff
changeset
|
401 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
|
402 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
|
403 Instead of `:t` you can use `:copy`. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
404 |
| 19303 | 405 |
| 406 Comparators ~ | |
| 407 | |
| 408 The 'ignorecase' option is not used for comparators that use strings. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
409 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
410 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
411 White space ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
412 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
413 Vim9 script enforces proper use of white space. This is no longer allowed: > |
| 22171 | 414 let var=234 # Error! |
| 415 let var= 234 # Error! | |
| 416 let var =234 # Error! | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
417 There must be white space before and after the "=": > |
| 22171 | 418 let var = 234 # OK |
| 21250 | 419 White space must also be put before the # that starts a comment after a |
| 420 command: > | |
|
20023
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
421 let var = 234# Error! |
|
c85d4e173cc9
patch 8.2.0567: Vim9: cannot put comments halfway expressions
Bram Moolenaar <Bram@vim.org>
parents:
20015
diff
changeset
|
422 let var = 234 # OK |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
423 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
424 White space is required around most operators. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
425 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
426 White space is not allowed: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
427 - Between a function name and the "(": > |
| 22171 | 428 call Func (arg) # Error! |
| 429 call Func | |
| 430 \ (arg) # Error! | |
| 431 call Func(arg) # OK | |
| 432 call Func( | |
| 433 \ arg) # OK | |
| 434 call Func( | |
| 435 \ arg # OK | |
|
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
|
436 \ ) |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
437 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
438 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
439 Conditions and expressions ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
440 |
| 21825 | 441 Conditions and expressions are mostly working like they do in JavaScript. A |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
442 difference is made where JavaScript does not work like most people expect. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
443 Specifically, an empty list is falsey. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
444 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
445 Any type of variable can be used as a condition, there is no error, not even |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
446 for using a list or job. This is very much like JavaScript, but there are a |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
447 few exceptions. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
448 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
449 type TRUE when ~ |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
450 bool 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
|
451 number non-zero |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
452 float non-zero |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
453 string non-empty |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
454 blob non-empty |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
455 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
|
456 dictionary non-empty (different from JavaScript) |
| 19968 | 457 func when there is a function name |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
458 special v:true |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
459 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
|
460 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
|
461 class when not NULL |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
462 object when not NULL (TODO: when isTrue() returns v:true) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
463 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
464 The boolean operators "||" and "&&" do not change the value: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
465 8 || 2 == 8 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
466 0 || 2 == 2 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
467 0 || '' == '' |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
468 8 && 2 == 2 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
469 0 && 2 == 0 |
|
21353
fb8c8fcb7b60
patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing
Bram Moolenaar <Bram@vim.org>
parents:
21250
diff
changeset
|
470 2 && 0 == 0 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
471 [] && 2 == [] |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
472 |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
473 When using `..` for string concatenation arguments of simple types are always |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
474 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
|
475 'hello ' .. 123 == 'hello 123' |
| 21825 | 476 'hello ' .. v:true == 'hello v:true' |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
477 |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
478 Simple types are string, float, special and bool. For other types |string()| |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
479 can be used. |
| 22171 | 480 *false* *true* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
481 In Vim9 script one can use "true" for v:true and "false" for v:false. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
482 |
| 21825 | 483 Indexing a string with [idx] or [idx, idx] uses character indexes instead of |
| 484 byte indexes. Example: > | |
| 485 echo 'bár'[1] | |
| 486 In legacy script this results in the character 0xc3 (an illegal byte), in Vim9 | |
| 487 script this results in the string 'á'. | |
| 488 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
489 |
| 21093 | 490 What to watch out for ~ |
| 491 *vim9-gotchas* | |
| 492 Vim9 was designed to be closer to often used programming languages, but at the | |
| 493 same time tries to support the legacy Vim commands. Some compromises had to | |
| 494 be made. Here is a summary of what might be unexpected. | |
| 495 | |
| 496 Ex command ranges need to be prefixed with a colon. > | |
| 22171 | 497 -> # legacy Vim: shifts the previous line to the right |
| 498 ->func() # Vim9: method call in continuation line | |
| 499 :-> # Vim9: shifts the previous line to the right | |
| 21093 | 500 |
| 22171 | 501 %s/a/b # legacy Vim: substitute on all lines |
| 21093 | 502 x = alongname |
| 22171 | 503 % another # Vim9: line continuation without a backslash |
| 504 :%s/a/b # Vim9: substitute on all lines | |
| 505 'text'->func() # Vim9: method call | |
| 506 :'t # legacy Vim: jump to mark m | |
| 21093 | 507 |
| 21676 | 508 Some Ex commands can be confused with assignments in Vim9 script: > |
| 509 g:name = value # assignment | |
| 510 g:pattern:cmd # invalid command - ERROR | |
| 511 :g:pattern:cmd # :global command | |
| 512 | |
| 21093 | 513 Functions defined with `:def` compile the whole function. Legacy functions |
| 514 can bail out, and the following lines are not parsed: > | |
| 515 func Maybe() | |
| 516 if !has('feature') | |
| 517 return | |
| 518 endif | |
| 519 use-feature | |
| 520 endfunc | |
| 521 Vim9 functions are compiled as a whole: > | |
| 522 def Maybe() | |
| 523 if !has('feature') | |
| 524 return | |
| 525 endif | |
| 22171 | 526 use-feature # May give compilation error |
| 21093 | 527 enddef |
| 528 For a workaround, split it in two functions: > | |
| 529 func Maybe() | |
| 530 if has('feature') | |
| 531 call MaybyInner() | |
| 532 endif | |
| 533 endfunc | |
| 534 if has('feature') | |
| 535 def MaybeInner() | |
| 536 use-feature | |
| 537 enddef | |
| 538 endif | |
| 22171 | 539 Or put the unsupported code inside an `if` with a constant expression that |
| 21991 | 540 evaluates to false: > |
| 541 def Maybe() | |
| 542 if has('feature') | |
| 543 use-feature | |
| 544 endif | |
| 545 enddef | |
| 546 Note that for unrecognized commands there is no check for "|" and a following | |
| 547 command. This will give an error for missing `endif`: > | |
| 548 def Maybe() | |
| 549 if has('feature') | use-feature | endif | |
| 550 enddef | |
| 21093 | 551 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
552 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
553 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
554 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
|
555 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
556 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
557 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
558 *:def* |
| 21825 | 559 :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
|
560 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
|
561 the function follows in the next lines, until the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
562 matching `:enddef`. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
563 |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
564 When {return-type} is omitted or is "void" the |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
565 function is not expected to return anything. |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
566 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
567 {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
|
568 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
|
569 {name}: {type} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
570 {name} = {value} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
571 {name}: {type} = {value} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
572 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
|
573 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
|
574 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
|
575 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
|
576 |
| 20856 | 577 The function will be compiled into instructions when |
| 21499 | 578 called, or when `:disassemble` or `:defcompile` is |
| 579 used. Syntax and type errors will be produced at that | |
| 580 time. | |
| 20856 | 581 |
| 21499 | 582 It is possible to nest `:def` inside another `:def` or |
| 583 `:function` up to about 50 levels deep. | |
| 19303 | 584 |
| 20552 | 585 [!] is used as with `:function`. Note that in Vim9 |
| 586 script script-local functions cannot be deleted or | |
| 20856 | 587 redefined later in 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
|
588 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
589 *:enddef* |
| 21499 | 590 :enddef End of a function defined with `:def`. It should be on |
| 591 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
|
592 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
593 |
|
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
|
594 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
|
595 variables can be accessed without the "s:" prefix. They must be defined |
| 20856 | 596 before the function is compiled. If the script the function is defined in is |
| 597 legacy script, then script-local variables must be accessed with the "s:" | |
| 21991 | 598 prefix and they do not need to exist (they can be deleted any time). |
|
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
|
599 |
| 20552 | 600 *:defc* *:defcompile* |
| 601 :defc[ompile] Compile functions defined in the current script that | |
| 602 were not compiled yet. | |
| 603 This will report errors found during the 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
|
604 |
| 19404 | 605 *:disa* *:disassemble* |
| 606 :disa[ssemble] {func} Show the instructions generated for {func}. | |
| 607 This is for debugging and testing. | |
|
19556
ff5048b0ccfe
patch 8.2.0335: no completion for :disassemble
Bram Moolenaar <Bram@vim.org>
parents:
19523
diff
changeset
|
608 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
|
609 can prepend "s:" to find script-local functions. |
| 19404 | 610 |
| 21250 | 611 Limitations ~ |
| 612 | |
| 613 Local variables will not be visible to string evaluation. For example: > | |
| 614 def EvalString(): list<string> | |
| 615 let list = ['aa', 'bb', 'cc', 'dd'] | |
| 616 return range(1, 2)->map('list[v:val]') | |
| 617 enddef | |
| 618 | |
| 619 The map argument is a string expression, which is evaluated without the | |
| 620 function scope. Instead, use a lambda: > | |
| 621 def EvalString(): list<string> | |
| 622 let list = ['aa', 'bb', 'cc', 'dd'] | |
| 623 return range(1, 2)->map({ _, v -> list[v] }) | |
| 624 enddef | |
| 625 | |
| 626 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
627 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
628 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
629 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
|
630 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
631 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
632 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
633 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
|
634 bool |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
635 number |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
636 float |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
637 string |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
638 blob |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
639 list<{type}> |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
640 dict<{type}> |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
641 job |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
642 channel |
| 19646 | 643 func |
| 19968 | 644 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
|
645 func({type}, ...) |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
646 func({type}, ...): {type} |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
647 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
648 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
|
649 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
|
650 |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
651 These types can be used in declarations, but no value will have this type: |
| 21499 | 652 {type}|{type} {not implemented yet} |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
653 void |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
654 any |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
655 |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
656 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
|
657 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
|
658 memory. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
659 |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
660 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
|
661 func any kind of function reference, no type |
| 19968 | 662 checking for arguments or return value |
|
19904
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
663 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
|
664 return type |
| 19968 | 665 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
|
666 a value |
| 19968 | 667 func({type}): {type} function with argument type and return type |
| 668 func(?{type}) function with type of optional argument, does | |
| 669 not return a value | |
| 670 func(...{type}) function with type of variable number of | |
| 671 arguments, does not return a value | |
| 672 func({type}, ?{type}, ...{type}): {type} | |
| 673 function with: | |
| 674 - type of mandatory argument | |
| 675 - type of optional argument | |
| 676 - type of variable number of arguments | |
| 677 - 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
|
678 |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
679 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
|
680 |
|
bd4f91762d0f
patch 8.2.0508: Vim9: func and partial types not done yet
Bram Moolenaar <Bram@vim.org>
parents:
19646
diff
changeset
|
681 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
|
682 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
|
683 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
|
684 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
685 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
|
686 :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
|
687 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
|
688 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
|
689 {not implemented yet} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
690 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
691 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
|
692 :class MyClass |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
693 :let mine: MyClass |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
694 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
695 :interface MyInterface |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
696 :let mine: MyInterface |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
697 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
698 :class MyTemplate<Targ> |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
699 :let mine: MyTemplate<number> |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
700 :let mine: MyTemplate<string> |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
701 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
702 :class MyInterface<Targ> |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
703 :let mine: MyInterface<number> |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
704 :let mine: MyInterface<string> |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
705 {not implemented yet} |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
706 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
707 |
|
21717
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
708 Variable types and type casting *variable-types* |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
709 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
710 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
|
711 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
|
712 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
713 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
|
714 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
|
715 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
|
716 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
717 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
|
718 expected to always be the same. For example, when declaring a list: > |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
719 let l: list<number> = [1, g:two] |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
720 This will give an error, because "g:two" has type "any". To avoid this, use a |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
721 type cast: > |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
722 let l: list<number> = [1, <number>g:two] |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
723 < *type-casting* |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
724 The compiled code will then check that "g:two" is a number at runtime and give |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
725 an error if it isn't. This is called type casting. |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
726 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
727 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
|
728 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
|
729 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
|
730 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
731 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
|
732 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
|
733 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
|
734 string to a number. |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
735 |
|
ef3b31d510d2
patch 8.2.1408: Vim9: type casting not supported
Bram Moolenaar <Bram@vim.org>
parents:
21715
diff
changeset
|
736 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
737 Type inference *type-inference* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
738 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
739 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
|
740 declaring a variable and giving it a value: > |
| 22171 | 741 let var = 0 # infers number type |
| 742 let var = '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
|
743 |
|
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
|
744 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
|
745 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
|
746 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
|
747 [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
|
748 ['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
|
749 [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
|
750 |
| 21991 | 751 |
| 752 Stricter type checking *type-checking* | |
| 753 | |
| 754 In legacy Vim script, where a number was expected, a string would be | |
| 755 automatically converted to a number. This was convenient for an actual number | |
| 756 such as "123", but leads to unexpected problems (but no error message) if the | |
| 757 string doesn't start with a number. Quite often this leads to hard-to-find | |
| 758 bugs. | |
| 759 | |
| 760 In Vim9 script this has been made stricter. In most places it works just as | |
| 22171 | 761 before, if the value used matches the expected type. There will sometimes be |
| 762 an error, thus breaking backwards compatibility. For example: | |
| 21991 | 763 - Using a number other than 0 or 1 where a boolean is expected. *E1023* |
| 764 - Using a string value when setting a number options. | |
| 765 - Using a number where a string is expected. *E1024* | |
| 766 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
767 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
768 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
769 5. Namespace, Import and Export |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
770 *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
|
771 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
772 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
773 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
774 A Vim9 script can be written to be imported. This means that everything in |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
775 the script is local, unless exported. Those exported items, and only those |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
776 items, can then be imported in another script. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
777 |
| 21991 | 778 You can cheat by using the global namespace explicitly. We will assume here |
| 779 that you don't do that. | |
| 780 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
781 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
782 Namespace ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
783 *:vim9script* *:vim9* |
| 19303 | 784 To recognize a file that can be imported the `vim9script` statement must |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
785 appear as the first statement in the file. It tells Vim to interpret the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
786 script in its own namespace, instead of the global namespace. If a file |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
787 starts with: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
788 vim9script |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
789 let myvar = 'yes' |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
790 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
|
791 be available as `g:myvar` from any other script and function. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
792 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
793 The variables at the file level are very much like the script-local "s:" |
| 20115 | 794 variables in legacy Vim script, but the "s:" is omitted. And they cannot be |
| 795 deleted. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
796 |
| 20115 | 797 In Vim9 script the global "g:" namespace can still be used as before. And the |
| 798 "w:", "b:" and "t:" namespaces. These have in common that variables are not | |
| 799 declared and they can be deleted. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
800 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
801 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
|
802 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
|
803 :set cpo&vim |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
804 One of the effects is that |line-continuation| is always enabled. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
805 The original value of 'cpoptions' is restored at the end of the script. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
806 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
807 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
808 Export ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
809 *:export* *:exp* |
| 21499 | 810 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
|
811 export const EXPORTED_CONST = 1234 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
812 export let someValue = ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
813 export def MyFunc() ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
814 export class MyClass ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
815 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
816 As this suggests, only constants, variables, `:def` functions and classes can |
| 21499 | 817 be exported. {classes are not implemented yet} |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
818 |
| 20856 | 819 *E1042* |
| 820 `: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
|
821 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
822 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
823 Import ~ |
| 20965 | 824 *:import* *:imp* *E1094* |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
825 The exported items can be imported individually in another Vim9 script: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
826 import EXPORTED_CONST from "thatscript.vim" |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
827 import MyClass from "myclass.vim" |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
828 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
829 To import multiple items at the same time: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
830 import {someValue, MyClass} from "thatscript.vim" |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
831 |
| 19303 | 832 In case the name is ambiguous, another name can be specified: > |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
833 import MyClass as ThatClass from "myclass.vim" |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
834 import {someValue, MyClass as ThatClass} from "myclass.vim" |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
835 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
836 To import all exported items under a specific identifier: > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
837 import * as That from 'thatscript.vim' |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
838 |
| 22328 | 839 {not implemented yet: using "This as That"} |
| 840 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
841 Then you can use "That.EXPORTED_CONST", "That.someValue", etc. You are free |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
842 to choose the name "That", but it is highly recommended to use the name of the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
843 script file to avoid confusion. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
844 |
| 22171 | 845 `:import` can also be used in legacy Vim script. The imported items still |
| 846 become script-local, even when the "s:" prefix is not given. | |
| 847 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
848 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
|
849 - 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
|
850 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
|
851 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
|
852 - An absolute path, starting with "/" on Unix or "D:/" on MS-Windows. This |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
853 will be rarely used. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
854 - 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
|
855 "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
|
856 longer and unique, to avoid loading the wrong file. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
857 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
858 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
|
859 next time the same script is imported. It will not be read again. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
860 *:import-cycle* |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
861 The `import` commands are executed when encountered. If that script (directly |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
862 or indirectly) imports the current script, then items defined after the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
863 `import` won't be processed yet. Therefore cyclic imports can exist, but may |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
864 result in undefined items. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
865 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
866 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
867 Import in an autoload script ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
868 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
869 For optimal startup speed, loading scripts should be postponed until they are |
| 19303 | 870 actually needed. A recommended mechanism: |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
871 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
872 1. In the plugin define user commands, functions and/or mappings that refer to |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
873 an autoload script. > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
874 command -nargs=1 SearchForStuff call searchfor#Stuff(<f-args>) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
875 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
876 < This goes in .../plugin/anyname.vim. "anyname.vim" can be freely chosen. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
877 |
| 21825 | 878 2. In the autoload script do the actual work. You can import items from |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
879 other files to split up functionality in appropriate pieces. > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
880 vim9script |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
881 import FilterFunc from "../import/someother.vim" |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
882 def searchfor#Stuff(arg: string) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
883 let filtered = FilterFunc(arg) |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
884 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
885 < This goes in .../autoload/searchfor.vim. "searchfor" in the file name |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
886 must be exactly the same as the prefix for the function name, that is how |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
887 Vim finds the file. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
888 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
889 3. Other functionality, possibly shared between plugins, contains the exported |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
890 items and any private items. > |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
891 vim9script |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
892 let localVar = 'local' |
| 22171 | 893 export def FilterFunc(arg: string): string |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
894 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
895 < This goes in .../import/someother.vim. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
896 |
|
21771
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
897 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
|
898 encountered, the script is not loaded until the `:def` function is called. |
|
fcf978444298
patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes
Bram Moolenaar <Bram@vim.org>
parents:
21717
diff
changeset
|
899 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
900 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
901 Import in legacy Vim script ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
902 |
| 20856 | 903 If an `import` statement is used in legacy Vim script, the script-local "s:" |
| 904 namespace will be used for the imported item, even when "s:" is not specified. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
905 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
906 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
907 ============================================================================== |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
908 |
| 22328 | 909 6. Future work: classes *vim9-classes* |
| 910 | |
| 911 Above "class" was mentioned a few times, but it has not been implemented yet. | |
| 912 Most of Vim9 script can be created without this funcionality, and since | |
| 913 implementing classes is going to be a lot of work, it is left for the future. | |
| 914 For now we'll just make sure classes can be added later. | |
| 915 | |
| 916 Thoughts: | |
| 917 - `class` / `endclass`, everything in one file | |
| 918 - Class names are always CamelCase | |
| 919 - Single constructor | |
| 920 - Single inheritance with `class ThisClass extends BaseClass` | |
| 921 - `abstract class` | |
| 922 - `interface` (Abstract class without any implementation) | |
| 923 - `class SomeClass implements SomeInterface` | |
| 924 - Generics for class: `class <Tkey, Tentry>` | |
| 925 - Generics for function: `def <Tkey> GetLast(key: Tkey)` | |
| 926 | |
| 927 Again, much of this is from TypeScript. | |
| 928 | |
| 929 Some things that look like good additions: | |
| 930 - Use a class as an interface (like Dart) | |
| 931 - Extend a class with methods, using an import (like Dart) | |
| 932 | |
| 933 An important class that will be provided is "Promise". Since Vim is single | |
| 934 threaded, connecting asynchronous operations is a natural way of allowing | |
| 935 plugins to do their work without blocking the user. It's a uniform way to | |
| 936 invoke callbacks and handle timeouts and errors. | |
| 937 | |
| 938 ============================================================================== | |
| 939 | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
940 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
|
941 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
942 The :def command ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
943 |
| 21825 | 944 Plugin writers have asked for a much faster Vim script. Investigations have |
| 19303 | 945 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
|
946 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
|
947 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
|
948 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
|
949 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
|
950 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
|
951 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
952 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
|
953 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
|
954 as before, but some parts do not. A new way to define a function was |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
955 considered the best way to separate the old-style code from Vim9 script code. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
956 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
957 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
|
958 "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
|
959 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
960 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
961 Type checking ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
962 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
963 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
|
964 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
|
965 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
|
966 encountering the "+" character and compiling this into a generic add |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
967 instruction, at execution time the instruction would have to inspect the type |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
968 of the arguments and decide what kind of addition to do. And when the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
969 type is dictionary throw an error. If the types are known to be numbers then |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
970 an "add number" instruction can be used, which is faster. The error can be |
| 22328 | 971 given at compile time, no error handling is needed at runtime, adding two |
| 972 numbers cannot fail. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
973 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
974 The syntax for types is similar to Java, since it is easy to understand and |
| 21825 | 975 widely used. The type names are what were used in Vim before, with some |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
976 additions such as "void" and "bool". |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
977 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
978 |
| 22328 | 979 Removing clutter and weirdness ~ |
| 20856 | 980 |
| 22328 | 981 Once decided that `:def` functions have different syntax than legacy functions, |
| 982 we are free to add improvements to make the code more familiar for users who | |
| 983 know popular programming languages. In other words: remove weird things that | |
| 984 only Vim uses. | |
| 985 | |
| 986 We can also remove clutter, mainly things that were done to make Vim script | |
| 987 backwards compatible with good old Vi commands. | |
| 20856 | 988 |
| 22328 | 989 Examples: |
| 990 - Drop `:call` for calling a function and `:eval` for manipulating data. | |
| 991 - Drop using a leading backslash for line continuation, automatically figure | |
| 992 out where an expression ends. | |
| 20856 | 993 |
| 22328 | 994 However, this does require that some things need to change: |
| 995 - Comments start with # instead of ", to avoid confusing them with strings. | |
| 996 - Ex command ranges need to be prefixed with a colon, to avoid confusion with | |
| 997 expressions (single quote can be a string or a mark, "/" can be divide or a | |
| 998 search command, etc.). | |
| 999 | |
| 1000 Goal is to limit the differences. A good criteria is that when the old syntax | |
| 1001 is used you are very likely to get an error message. | |
| 20856 | 1002 |
| 1003 | |
| 1004 TypeScript syntax and semantics ~ | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1005 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1006 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
|
1007 different from what they are used to. To reduce this complaint popular |
| 20856 | 1008 languages are used as an example. At the same time, we do not want to abandon |
| 1009 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
|
1010 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1011 Since Vim already uses `:let` and `:const` and optional type checking is |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1012 desirable, the JavaScript/TypeScript syntax fits best for variable |
| 22171 | 1013 declarations: > |
| 1014 const greeting = 'hello' # string type is inferred | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1015 let name: string |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1016 ... |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1017 name = 'John' |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1018 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1019 Expression evaluation was already close to what JavaScript and other languages |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1020 are doing. Some details are unexpected and can be fixed. For example how the |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1021 || and && operators work. Legacy Vim script: > |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1022 let value = 44 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1023 ... |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1024 let result = value || 0 # result == 1 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1025 |
| 21825 | 1026 Vim9 script works like JavaScript/TypeScript, keep the value: > |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1027 let value = 44 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1028 ... |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1029 let result = value || 0 # result == 44 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1030 |
| 22328 | 1031 Another reason why TypeScript can be used as an example for Vim9 script is the |
| 1032 mix of static typing (a variable always has a known value type) and dynamic | |
| 1033 typing (a variable can have different types, this hanges at runtime). Since | |
| 1034 legacy Vim script is dynamically typed and a lot of existing functionality | |
| 1035 (esp. builtin functions) depends on that, while static typing allows for much | |
| 1036 faster execution, we need to have this mix in Vim9 script. | |
| 1037 | |
| 22171 | 1038 There is no intention to completely match TypeScript syntax and semantics. We |
| 1039 just want to take those parts that we can use for Vim and we expect Vim users | |
| 22328 | 1040 will be happy with. TypeScript is a complex language with its own history, |
| 1041 advantages and disadvantages. To get an idea of the disadvantages read the | |
| 1042 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
|
1043 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
|
1044 |
| 22328 | 1045 People familiar with other languages (Java, Python, etc.) will also find |
| 1046 things in TypeScript that they do not like or do not understand. We'll try to | |
| 1047 avoid those things. | |
|
22272
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1048 |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1049 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
|
1050 - 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
|
1051 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
|
1052 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
|
1053 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
|
1054 - 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
|
1055 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
|
1056 annoying. Vim recognizes an expression with && or || and allows using the |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1057 result as a bool. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1058 - 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
|
1059 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
|
1060 Falsy. |
|
eb1f5f618c75
patch 8.2.1685: Vim9: cannot declare a constant value
Bram Moolenaar <Bram@vim.org>
parents:
22171
diff
changeset
|
1061 - 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
|
1062 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
|
1063 which is more flexible, but is only checked at runtime. |
| 22171 | 1064 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1065 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1066 Import and Export ~ |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1067 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1068 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
|
1069 are global. It is possible to make them script-local, but then they are not |
| 22171 | 1070 available in other scripts. This defies the concept of a package that only |
| 1071 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
|
1072 |
| 21825 | 1073 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
|
1074 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
|
1075 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
|
1076 - Instead of making everything global by default, everything is script-local, |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1077 unless exported. |
| 22171 | 1078 - When importing a script the symbols that are imported are explicitly listed, |
| 1079 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
|
1080 - The mechanism allows for writing a big, long script with a very clear API: |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1081 the exported function(s) and class(es). |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1082 - 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
|
1083 package, no need to search many directories. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1084 - Once an import has been used, it can be cached and loading it again can be |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1085 avoided. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1086 - 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
|
1087 |
| 20856 | 1088 When sourcing a Vim9 script from a legacy script, only the items defined |
| 1089 globally can be used, not the exported items. Alternatives considered: | |
| 1090 - All the exported items become available as script-local items. This makes | |
| 22171 | 1091 it uncontrollable what items get defined and likely soon leads to trouble. |
| 20856 | 1092 - Use the exported items and make them global. Disadvantage is that it's then |
| 1093 not possible to avoid name clashes in the global namespace. | |
| 1094 - Completely disallow sourcing a Vim9 script, require using `:import`. That | |
| 1095 makes it difficult to use scripts for testing, or sourcing them from the | |
| 1096 command line to try them out. | |
| 22171 | 1097 Note that you can also use `:import` in legacy Vim script, see above. |
| 20856 | 1098 |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1099 |
| 22328 | 1100 Compiling functions early ~ |
| 1101 | |
| 1102 Functions are compiled when called or when `:defcompile` is used. Why not | |
| 1103 compile them early, so that syntax and type errors are reported early? | |
| 1104 | |
| 1105 The functions can't be compiled right away when encountered, because there may | |
| 1106 be forward references to functions defined later. Consider defining functions | |
| 1107 A, B and C, where A calls B, B calls C, and C calls A again. It's impossible | |
| 1108 to reorder the functions to avoid forward references. | |
| 1109 | |
| 1110 An alternative would be to first scan through the file to locate items and | |
| 1111 figure out their type, so that forward references are found, and only then | |
| 1112 execute the script and compile the functions. This means the script has to be | |
| 1113 parsed twice, which is slower, and some conditions at the script level, such | |
| 1114 as checking if a feature is supported, are hard to use. An attempt was made | |
| 1115 to see if it works, but it turned out to be impossible to make work nicely. | |
| 1116 | |
| 1117 It would be possible to compile all the functions at the end of the script. | |
| 1118 The drawback is that if a function never gets called, the overhead of | |
| 1119 compiling it counts anyway. Since startup speed is very important, in most | |
| 1120 cases it's better to do it later and accept that syntax and type errors are | |
| 1121 only reported then. In case these errors should be found early, e.g. when | |
| 1122 testing, the `:defcompile` command will help out. | |
| 1123 | |
| 1124 | |
| 1125 Why not use an embeded language? ~ | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1126 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1127 Vim supports interfaces to Perl, Python, Lua, Tcl and a few others. But |
| 22328 | 1128 these interfaces have never become widely used, for various reasons. When |
| 1129 Vim9 was designed a decision was made to make these interfaces lower priority | |
| 1130 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
|
1131 |
| 22328 | 1132 Still, plugin writers may find other languages more familiar, want to use |
| 1133 existing libraries or see a performance benefit. We encourage plugin authors | |
| 1134 to write code in any language and run it as an external tool, using jobs and | |
| 1135 channels. We can try to make this easier somehow. | |
| 1136 | |
| 1137 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
|
1138 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
|
1139 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
|
1140 tool need to be supported. Since most languages support classes the lack of |
| 22171 | 1141 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
|
1142 |
| 22328 | 1143 |
| 1144 Classes ~ | |
| 1145 | |
| 1146 Vim supports a kind-of object oriented programming by adding methods to a | |
| 1147 dictionary. With some care this can be made to work, but it does not look | |
| 1148 like real classes. On top of that, it's quite slow, because of the use of | |
| 1149 dictionaries. | |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1150 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1151 The support of classes in Vim9 script is a "minimal common functionality" of |
| 22171 | 1152 class support in most languages. It works much like Java, which is the most |
|
19181
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1153 popular programming language. |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1154 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1155 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1156 |
|
94eda51ba9ba
patch 8.2.0149: maintaining a Vim9 branch separately is more work
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1157 vim:tw=78:ts=8:noet:ft=help:norl: |