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