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