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