vim: runtime/doc/vim9.txt annotate

annotate runtime/doc/vim9.txt @ 28260:21f8175f4d9f

Added tag v8.2.4655 for changeset 0f1a0bef2c02dbc13f1e4bf9670d1f5fac337bd4

author	Bram Moolenaar <Bram@vim.org>
date	Thu, 31 Mar 2022 13:45:05 +0200
parents	e3d6184b89fa
children	6dd88e45d47d

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

Mercurial > vim

annotate runtime/doc/vim9.txt @ 28260:21f8175f4d9f