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