vim: runtime/doc/vim9.txt annotate

annotate runtime/doc/vim9.txt @ 21750:3a928a619b67

Added tag v8.2.1424 for changeset e86237409bd20b0e6d8909e9ed8b43fd904b7589

author	Bram Moolenaar <Bram@vim.org>
date	Tue, 11 Aug 2020 23:15:05 +0200
parents	ef3b31d510d2
children	fcf978444298

rev	line source
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	1 vim9.txt For Vim version 8.2. Last change: 2020 Aug 01
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4 VIM REFERENCE MANUAL by Bram Moolenaar
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	7 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	8
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	9 Vim9 script commands and expressions. vim9
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	10
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	11 Most expression help is in \|eval.txt\|. This file is about the new syntax and
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	12 features in Vim9 script.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	13
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	14 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	15
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	16
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	17 1. What is Vim9 script? \|vim9-script\|
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	18 2. Differences \|vim9-differences\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	19 3. New style functions \|fast-functions\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	20 4. Types \|vim9-types\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	21 5. Namespace, Import and Export \|vim9script\|
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 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	24
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	25 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	26
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	27 1. What is Vim9 script? vim9-script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	28
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	29 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	30
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	31 Vim script has been growing over time, while preserving backwards
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	32 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	33 and compatibility with Vi restricts possible solutions. Execution is quite
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	34 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	35
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	36 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	37 accomplished by compiling commands into instructions that can be efficiently
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	38 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	39
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	40 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	41 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	42
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	43 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	44 compatible. For example, making function arguments available in the
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	45 "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	46 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	47 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	48
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	49 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	50 - 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	51 - a script file where the first command is `vim9script`
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	52
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	53 When using `:function` in a Vim9 script file the legacy syntax is used.
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	54 However, this can be confusing and is therefore discouraged.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	55
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	56 Vim9 script and legacy Vim script can be mixed. There is no requirement to
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	57 rewrite old scripts, they keep working as before.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	58
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	59 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	60
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	61 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	62
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	63 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	64
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	65 Comments starting with # ~
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	66
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	67 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	68 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	69 # declarations
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	70 let 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	71
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	72 The reason is that a double quote can also be the start of a string. In many
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	73 places, especially halfway an expression with a line break, it's hard to tell
21516 c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	74 what the meaning is, since both a string and a comment can be followed by
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	75 arbitrary text. To avoid confusion only # comments are recognized. This is
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	76 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	77
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	78 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	79 `:number` for that. >
21516 c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	80 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	81
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	82 To improve readability there must be a space between a command and the #
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	83 that starts a comment. Note that #{ is the start of a dictionary, therefore
21516 c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	84 it does not start a comment.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	85
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	86
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	87 Vim9 functions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	88
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	89 A function defined with `:def` is compiled. Execution is many times faster,
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	90 often 10x to 100x times.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	91
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	92 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	93 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	94
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	95 Compilation is done when the function is first called, or when the
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	96 `:defcompile` command is encountered in the script where the function was
21516 c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	97 defined. `:disassemble` also compiles the function.
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	98
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	99 `:def` has no options like `:function` does: "range", "abort", "dict" or
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	100 "closure". A `:def` function always aborts on an error, does not get a range
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	101 passed and cannot be a "dict" function.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	102
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	103 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	104 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	105 functions.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	106
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	107 Arguments are accessed by name, without "a:". There is no "a:" dictionary or
21516 c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	108 "a:000" list. Just like any other language.
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	109
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	110 Variable arguments are defined as the last argument, with a name and have a
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	111 list type, similar to Typescript. For example, a list of numbers: >
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	112 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	113 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	114 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	115
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	116
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	117 Functions and variables are script-local by default ~
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	118 vim9-scopes
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	119 When using `:function` or `:def` to specify a new function at the script level
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	120 in a Vim9 script, the function is local to the script, as if "s:" was
21550 b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	121 prefixed. Using the "s:" prefix is optional. To define or use a global
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	122 function or variable the "g:" prefix should be used. For functions in an
21550 b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	123 autoload script the "name#" prefix is sufficient. >
b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	124 def ThisFunction() # script-local
b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	125 def s:ThisFunction() # script-local
b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	126 def g:ThatFunction() # global
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	127 def ThatFunction() # global if no local ThatFunction()
21550 b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	128 def scriptname#function() # autoload
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	129
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	130 When using `:function` or `:def` to specify a new function inside a function,
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	131 the function is local to the function. It is not possible to define a
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	132 script-local function inside a function. It is possible to define a global
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	133 function, using the "g:" prefix.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	134
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	135 When referring to a function and no "s:" or "g:" prefix is used, Vim will
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	136 prefer using a local function (in the function scope, script scope or
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	137 imported) before looking for a global function.
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	138 In all cases the function must be defined before used. That is when it is
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	139 first called or when `:defcompile` causes the call to be compiled.
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	140
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	141 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	142 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	143 variables could be defined anywhere (good luck finding out where!).
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	144
20317 2334bf788e8a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20241 diff changeset	145 Global functions can be still be defined and deleted at nearly any time. In
2334bf788e8a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20241 diff changeset	146 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	147 and cannot be deleted or replaced.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	148
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	149
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	150 Variable declarations with :let and :const ~
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	151 vim9-declaration
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	152 Local variables need to be declared with `:let`. Local constants need to be
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	153 declared with `:const`. We refer to both as "variables".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	154
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	155 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	156 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	157 let script_var = 123
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	158 def SomeFunc()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	159 let func_var = script_var
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	160 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	161 let block_var = func_var
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	162 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	163
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	164 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	165 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	166 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	167 let inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	168 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	169 let inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	170 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	171 echo inner " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	172
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	173 The declaration must be done earlier: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	174 let inner: number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	175 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	176 inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	177 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	178 inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	179 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	180 echo inner
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	181
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	182 To intentionally avoid a variable being available later, a block can be used:
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	183 >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	184 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	185 let temp = 'temp'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	186 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	187 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	188 echo temp " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	189
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	190 An existing variable cannot be assigned to with `:let`, since that implies a
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	191 declaration. Global, window, tab, buffer and Vim variables can only be used
21584 d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	192 without `:let`, because they are not really declared, they can also be deleted
d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	193 with `:unlet`.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	194
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	195 Variables and functions cannot shadow previously defined or imported variables
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	196 and functions.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	197 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	198
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	199 Global variables and user defined functions must be prefixed with "g:", also
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	200 at the script level. >
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	201 vim9script
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	202 let script_local = 'text'
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	203 g:global = 'value'
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	204 let Funcref = g:ThatFunction
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	205
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	206 Since "&opt = value" is now assigning a value to option "opt", ":&" cannot be
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	207 used to repeat a `:substitute` command.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	208
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	209 E1092
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	210 Declaring more than one variable at a time, using the unpack notation, is
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	211 currently not supported: >
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	212 let [v1, v2] = GetValues() # Error!
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	213 That is because the type needs to be inferred from the list item type, which
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	214 isn't that easy.
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	215
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	216
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	217 Omitting :call and :eval ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	218
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	219 Functions can be called without `:call`: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	220 writefile(lines, 'file')
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	221 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	222
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	223 A method call without `eval` is possible, so long as the start is an
21516 c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	224 identifier or can't be an Ex command. Examples: >
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	225 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	226 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	227 [1, 2, 3]->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	228 #{a: 1, b: 2}->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	229 {'a': 1, 'b': 2}->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	230 "foobar"->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	231 ("foobar")->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	232 'foobar'->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	233 ('foobar')->Process()
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	234
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	235 In rare case there is ambiguity between a function name and an Ex command,
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	236 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	237 is both the `:substitute` command and the `substitute()` function. When the
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	238 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	239 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	240 :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	241
19556 ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	242 Note that while variables need to be defined before they can be used,
ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	243 functions can be called before being defined. This is required to be able
ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	244 have cyclic dependencies between functions. It is slightly less efficient,
ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	245 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	246 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	247
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	248
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	249 Omitting function() ~
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	250
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	251 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	252 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	253 The function must already have been defined. >
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	254
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	255 let Funcref = MyFunction
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	256
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	257 When using `function()` the resulting type is "func", a function with any
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	258 number of arguments and any return type. The function can be defined later.
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	259
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	260
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	261 Automatic line continuation ~
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	262
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	263 In many cases it is obvious that an expression continues on the next line. In
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	264 those cases there is no need to prefix the line with a backslash
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	265 \|line-continuation\|. For example, when a list spans multiple lines: >
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	266 let mylist = [
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	267 'one',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	268 'two',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	269 ]
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	270 And when a dict spans multiple lines: >
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	271 let mydict = #{
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	272 one: 1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	273 two: 2,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	274 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	275 Function call: >
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	276 let result = Func(
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	277 arg1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	278 arg2
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	279 )
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	280
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	281 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	282 possible just before or after the operator. For example: >
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	283 let text = lead
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	284 .. middle
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	285 .. end
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	286 let total = start +
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	287 end -
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	288 correction
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	289 let result = positive
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	290 ? 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	291 : 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	292
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	293 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	294 before it: >
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	295 let result = GetBuilder()
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	296 ->BuilderSetWidth(333)
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	297 ->BuilderSetHeight(777)
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	298 ->BuilderBuild()
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	299 let result = MyDict
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	300 .member
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	301
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	302 < E1050
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	303 To make it possible for the operator at the start of the line to be
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	304 recognized, it is required to put a colon before a range. This will add
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	305 "start" and print: >
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	306 let result = start
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	307 + print
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	308 Like this: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	309 let result = start + print
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	310
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	311 This will assign "start" and print a line: >
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	312 let result = start
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	313 :+ print
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	314
20015 c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	315 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	316 arguments: >
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	317 def MyFunc(
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	318 text: string,
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	319 separator = '-'
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	320 ): string
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	321
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	322 Notes:
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	323 - "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	324 current function.
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	325 - 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	326 unpacking a list \|:let-unpack\|. This is OK: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	327 [var1, var2] =
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	328 Func()
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	329 < This does not work: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	330 [var1,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	331 var2] =
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	332 Func()
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	333 - 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	334 similar commands. This is OK: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	335 echo [1,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	336 2] [3,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	337 4]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	338 < This does not work: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	339 echo [1, 2]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	340 [3, 4]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	341 - No line break is allowed in the arguments of a lambda, between the "{" and
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	342 "->". This is OK: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	343 filter(list, {k, v ->
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	344 v > 0})
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	345 < This does not work: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	346 filter(list, {k,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	347 v -> v > 0})
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	348
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	349
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	350 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	351
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	352 \|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	353
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	354
21584 d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	355 No :xit, :t, :append, :change or :insert ~
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	356
21584 d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	357 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	358 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	359 Instead of `:t` you can use `:copy`.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	360
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	361
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	362 Comparators ~
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	363
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	364 The 'ignorecase' option is not used for comparators that use strings.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	365
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	366
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	367 White space ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	368
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	369 Vim9 script enforces proper use of white space. This is no longer allowed: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	370 let var=234 " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	371 let var= 234 " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	372 let var =234 " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	373 There must be white space before and after the "=": >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	374 let var = 234 " OK
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	375 White space must also be put before the # that starts a comment after a
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	376 command: >
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	377 let var = 234# Error!
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	378 let var = 234 # OK
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	379
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	380 White space is required around most operators.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	381
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	382 White space is not allowed:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	383 - Between a function name and the "(": >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	384 call Func (arg) " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	385 call Func
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	386 \ (arg) " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	387 call Func(arg) " OK
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	388 call Func(
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	389 \ arg) " OK
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	390 call Func(
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	391 \ arg " OK
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	392 \ )
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	393
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	394
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	395 Conditions and expressions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	396
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	397 Conditions and expression are mostly working like they do in JavaScript. A
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	398 difference is made where JavaScript does not work like most people expect.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	399 Specifically, an empty list is falsey.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	400
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	401 Any type of variable can be used as a condition, there is no error, not even
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	402 for using a list or job. This is very much like JavaScript, but there are a
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	403 few exceptions.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	404
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	405 type TRUE when ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	406 bool v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	407 number non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	408 float non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	409 string non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	410 blob non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	411 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	412 dictionary non-empty (different from JavaScript)
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	413 func when there is a function name
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	414 special v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	415 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	416 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	417 class when not NULL
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	418 object when not NULL (TODO: when isTrue() returns v:true)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	419
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	420 The boolean operators "\|\|" and "&&" do not change the value: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	421 8 \|\| 2 == 8
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	422 0 \|\| 2 == 2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	423 0 \|\| '' == ''
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	424 8 && 2 == 2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	425 0 && 2 == 0
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	426 2 && 0 == 0
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	427 [] && 2 == []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	428
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	429 When using `..` for string concatenation the arguments are always converted to
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	430 string. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	431 'hello ' .. 123 == 'hello 123'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	432 'hello ' .. v:true == 'hello true'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	433
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	434 In Vim9 script one can use "true" for v:true and "false" for v:false.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	435
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	436
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	437 What to watch out for ~
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	438 vim9-gotchas
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	439 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	440 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	441 be made. Here is a summary of what might be unexpected.
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	442
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	443 Ex command ranges need to be prefixed with a colon. >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	444 -> " legacy Vim: shifts the previous line to the right
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	445 ->func() " Vim9: method call in continuation line
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	446 :-> " Vim9: shifts the previous line to the right
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	447
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	448 %s/a/b " legacy Vim: substitute on all lines
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	449 x = alongname
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	450 % another " Vim9: line continuation without a backslash
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	451 :%s/a/b " Vim9: substitute on all lines
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	452 'text'->func() " Vim9: method call
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	453 :'t " legacy Vim: jump to mark m
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	454
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	455 Some Ex commands can be confused with assignments in Vim9 script: >
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	456 g:name = value # assignment
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	457 g:pattern:cmd # invalid command - ERROR
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	458 :g:pattern:cmd # :global command
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	459
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	460 Functions defined with `:def` compile the whole function. Legacy functions
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	461 can bail out, and the following lines are not parsed: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	462 func Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	463 if !has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	464 return
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	465 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	466 use-feature
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	467 endfunc
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	468 Vim9 functions are compiled as a whole: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	469 def Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	470 if !has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	471 return
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	472 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	473 use-feature " May give compilation error
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	474 enddef
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	475 For a workaround, split it in two functions: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	476 func Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	477 if has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	478 call MaybyInner()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	479 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	480 endfunc
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	481 if has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	482 def MaybeInner()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	483 use-feature
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	484 enddef
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	485 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	486
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	487 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	488
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	489 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	490
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	491 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	492
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	493 :def
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	494 :def[!] {name}([arguments])[: {return-type}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	495 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	496 the function follows in the next lines, until the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	497 matching `:enddef`.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	498
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	499 When {return-type} is omitted or is "void" the
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	500 function is not expected to return anything.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	501
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	502 {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	503 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	504 {name}: {type}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	505 {name} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	506 {name}: {type} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	507 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	508 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	509 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	510 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	511
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	512 The function will be compiled into instructions when
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	513 called, or when `:disassemble` or `:defcompile` is
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	514 used. Syntax and type errors will be produced at that
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	515 time.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	516
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	517 It is possible to nest `:def` inside another `:def` or
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	518 `:function` up to about 50 levels deep.
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	519
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	520 [!] is used as with `:function`. Note that in Vim9
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	521 script script-local functions cannot be deleted or
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	522 redefined later in 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	523
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	524 :enddef
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	525 :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	526 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	527
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	528
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	529 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	530 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	531 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	532 legacy script, then script-local variables must be accessed with the "s:"
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	533 prefix.
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	534
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	535 :defc :defcompile
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	536 :defc[ompile] Compile functions defined in the current script that
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	537 were not compiled yet.
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	538 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	539
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	540 :disa :disassemble
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	541 :disa[ssemble] {func} Show the instructions generated for {func}.
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	542 This is for debugging and testing.
19556 ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	543 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	544 can prepend "s:" to find script-local functions.
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	545
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	546 Limitations ~
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	547
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	548 Local variables will not be visible to string evaluation. For example: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	549 def EvalString(): list<string>
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	550 let list = ['aa', 'bb', 'cc', 'dd']
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	551 return range(1, 2)->map('list[v:val]')
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	552 enddef
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	553
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	554 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	555 function scope. Instead, use a lambda: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	556 def EvalString(): list<string>
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	557 let list = ['aa', 'bb', 'cc', 'dd']
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	558 return range(1, 2)->map({ _, v -> list[v] })
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	559 enddef
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	560
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	561
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	562 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	563
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	564 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	565
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	566 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	567
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	568 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	569 bool
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	570 number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	571 float
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	572 string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	573 blob
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	574 list<{type}>
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	575 dict<{type}>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	576 job
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	577 channel
19646 847a300aa244 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19574 diff changeset	578 func
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	579 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	580 func({type}, ...)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	581 func({type}, ...): {type}
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	582
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	583 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	584 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	585
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	586 These types can be used in declarations, but no value will have this type:
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	587 {type}\|{type} {not implemented yet}
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	588 void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	589 any
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	590
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	591 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	592 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	593 memory.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	594
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	595 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	596 func any kind of function reference, no type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	597 checking for arguments or return value
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	598 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	599 return type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	600 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	601 a value
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	602 func({type}): {type} function with argument type and return type
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	603 func(?{type}) function with type of optional argument, does
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	604 not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	605 func(...{type}) function with type of variable number of
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	606 arguments, does not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	607 func({type}, ?{type}, ...{type}): {type}
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	608 function with:
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	609 - type of mandatory argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	610 - type of optional argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	611 - type of variable number of arguments
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	612 - 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	613
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	614 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	615
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	616 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	617 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	618 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	619
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	620 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	621 :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	622 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	623 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	624 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	625
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	626 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	627 :class MyClass
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	628 :let mine: MyClass
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	629
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	630 :interface MyInterface
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	631 :let mine: MyInterface
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	632
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	633 :class MyTemplate<Targ>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	634 :let mine: MyTemplate<number>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	635 :let mine: MyTemplate<string>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	636
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	637 :class MyInterface<Targ>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	638 :let mine: MyInterface<number>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	639 :let mine: MyInterface<string>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	640 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	641
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	642
21717 ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	643 Variable types and type casting variable-types
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	644
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	645 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	646 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	647
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	648 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	649 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	650 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	651
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	652 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	653 expected to always be the same. For example, when declaring a list: >
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	654 let l: list<number> = [1, g:two]
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	655 This will give an error, because "g:two" has type "any". To avoid this, use a
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	656 type cast: >
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	657 let l: list<number> = [1, <number>g:two]
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	658 < type-casting
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	659 The compiled code will then check that "g:two" is a number at runtime and give
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	660 an error if it isn't. This is called type casting.
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	661
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	662 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	663 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	664 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	665
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	666 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	667 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	668 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	669 string to a number.
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	670
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	671
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	672 Type inference type-inference
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	673
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	674 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	675 declaring a variable and giving it a value: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	676 let var = 0 " infers number type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	677 let var = 'hello' " infers string type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	678
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	679 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	680 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	681 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	682 [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	683 ['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	684 [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	685
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	686 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	687
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	688 5. Namespace, Import and Export
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	689 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	690
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	691 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	692
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	693 A Vim9 script can be written to be imported. This means that everything in
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	694 the script is local, unless exported. Those exported items, and only those
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	695 items, can then be imported in another script.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	696
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	697
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	698 Namespace ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	699 :vim9script :vim9
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	700 To recognize a file that can be imported the `vim9script` statement must
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	701 appear as the first statement in the file. It tells Vim to interpret the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	702 script in its own namespace, instead of the global namespace. If a file
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	703 starts with: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	704 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	705 let myvar = 'yes'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	706 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	707 be available as `g:myvar` from any other script and function.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	708
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	709 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	710 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	711 deleted.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	712
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	713 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	714 "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	715 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	716
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	717 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	718 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	719 :set cpo&vim
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	720 One of the effects is that \|line-continuation\| is always enabled.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	721 The original value of 'cpoptions' is restored at the end of the script.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	722
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	723
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	724 Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	725 :export :exp
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	726 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	727 export const EXPORTED_CONST = 1234
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	728 export let someValue = ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	729 export def MyFunc() ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	730 export class MyClass ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	731
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	732 As this suggests, only constants, variables, `:def` functions and classes can
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	733 be exported. {classes are not implemented yet}
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	734
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	735 E1042
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	736 `: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	737
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	738
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	739 Import ~
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	740 :import :imp E1094
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	741 The exported items can be imported individually in another Vim9 script: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	742 import EXPORTED_CONST from "thatscript.vim"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	743 import MyClass from "myclass.vim"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	744
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	745 To import multiple items at the same time: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	746 import {someValue, MyClass} from "thatscript.vim"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	747
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	748 In case the name is ambiguous, another name can be specified: >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	749 import MyClass as ThatClass from "myclass.vim"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	750 import {someValue, MyClass as ThatClass} from "myclass.vim"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	751
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	752 To import all exported items under a specific identifier: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	753 import * as That from 'thatscript.vim'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	754
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	755 Then you can use "That.EXPORTED_CONST", "That.someValue", etc. You are free
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	756 to choose the name "That", but it is highly recommended to use the name of the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	757 script file to avoid confusion.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	758
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	759 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	760 - 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	761 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	762 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	763 - An absolute path, starting with "/" on Unix or "D:/" on MS-Windows. This
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	764 will be rarely used.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	765 - 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	766 "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	767 longer and unique, to avoid loading the wrong file.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	768
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	769 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	770 next time the same script is imported. It will not be read again.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	771 :import-cycle
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	772 The `import` commands are executed when encountered. If that script (directly
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	773 or indirectly) imports the current script, then items defined after the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	774 `import` won't be processed yet. Therefore cyclic imports can exist, but may
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	775 result in undefined items.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	776
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	777
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	778 Import in an autoload script ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	779
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	780 For optimal startup speed, loading scripts should be postponed until they are
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	781 actually needed. A recommended mechanism:
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	782
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	783 1. In the plugin define user commands, functions and/or mappings that refer to
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	784 an autoload script. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	785 command -nargs=1 SearchForStuff call searchfor#Stuff(<f-args>)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	786
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	787 < This goes in .../plugin/anyname.vim. "anyname.vim" can be freely chosen.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	788
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	789 2. In the autocommand script do the actual work. You can import items from
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	790 other files to split up functionality in appropriate pieces. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	791 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	792 import FilterFunc from "../import/someother.vim"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	793 def searchfor#Stuff(arg: string)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	794 let filtered = FilterFunc(arg)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	795 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	796 < This goes in .../autoload/searchfor.vim. "searchfor" in the file name
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	797 must be exactly the same as the prefix for the function name, that is how
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	798 Vim finds the file.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	799
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	800 3. Other functionality, possibly shared between plugins, contains the exported
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	801 items and any private items. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	802 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	803 let localVar = 'local'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	804 export def FilterFunc(arg: string): string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	805 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	806 < This goes in .../import/someother.vim.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	807
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	808
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	809 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	810
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	811 If an `import` statement is used in legacy Vim script, the script-local "s:"
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	812 namespace will be used for the imported item, even when "s:" is not specified.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	813
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	814
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	815 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	816
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	817 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	818
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	819 The :def command ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	820
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	821 Plugin writers have asked for a much faster Vim script. Investigation have
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	822 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	823 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	824 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	825 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	826 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	827 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	828
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	829 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	830 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	831 as before, but some parts do not. A new way to define a function was
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	832 considered the best way to separate the old-style code from Vim9 script code.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	833
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	834 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	835 "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	836
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	837
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	838 Type checking ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	839
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	840 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	841 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	842 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	843 encountering the "+" character and compiling this into a generic add
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	844 instruction, at execution time the instruction would have to inspect the type
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	845 of the arguments and decide what kind of addition to do. And when the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	846 type is dictionary throw an error. If the types are known to be numbers then
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	847 an "add number" instruction can be used, which is faster. The error can be
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	848 given at compile time, no error handling is needed at runtime.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	849
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	850 The syntax for types is similar to Java, since it is easy to understand and
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	851 widely used. The type names are what was used in Vim before, with some
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	852 additions such as "void" and "bool".
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	853
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	854
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	855 Compiling functions early ~
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	856
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	857 Functions are compiled when called or when `:defcompile` is used. Why not
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	858 compile them early, so that syntax and type errors are reported early?
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	859
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	860 The functions can't be compiled right away when encountered, because there may
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	861 be forward references to functions defined later. Consider defining functions
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	862 A, B and C, where A calls B, B calls C, and C calls A again. It's impossible
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	863 to reorder the functions to avoid forward references.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	864
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	865 An alternative would be to first scan through the file to locate items and
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	866 figure out their type, so that forward references are found, and only then
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	867 execute the script and compile the functions. This means the script has to be
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	868 parsed twice, which is slower, and some conditions at the script level, such
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	869 as checking if a feature is supported, are hard to use. An attempt was made
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	870 to see if it works, but it turned out to be impossible to make work nicely.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	871
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	872 It would be possible to compile all the functions at the end of the script.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	873 The drawback is that if a function never gets called, the overhead of
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	874 compiling it counts anyway. Since startup speed is very important, in most
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	875 cases it's better to do it later and accept that syntax and type errors are
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	876 only reported then. In case these errors should be found early, e.g. when
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	877 testing, the `:defcompile` command will help out.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	878
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	879
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	880 TypeScript syntax and semantics ~
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	881
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	882 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	883 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	884 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	885 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	886
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	887 Since Vim already uses `:let` and `:const` and optional type checking is
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	888 desirable, the JavaScript/TypeScript syntax fits best for variable
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	889 declarations. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	890 const greeting = 'hello' " string type is inferred
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	891 let name: string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	892 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	893 name = 'John'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	894
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	895 Expression evaluation was already close to what JavaScript and other languages
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	896 are doing. Some details are unexpected and can be fixed. For example how the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	897 \|\| and && operators work. Legacy Vim script: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	898 let result = 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	899 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	900 return result \|\| 0 " returns 1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	901
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	902 Vim9 script works like JavaScript/Typescript, keep the value: >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	903 let result = 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	904 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	905 return result \|\| 0 " returns 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	906
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	907 On the other hand, overloading "+" to use both for addition and string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	908 concatenation goes against legacy Vim script and often leads to mistakes.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	909 For that reason we will keep using ".." for string concatenation. Lua also
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	910 uses ".." this way.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	911
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	912
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	913 Import and Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	914
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	915 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	916 are global. It is possible to make them script-local, but then they are not
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	917 available in other scripts.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	918
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	919 In Vim9 script a mechanism very similar to the Javascript import and export
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	920 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	921 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	922 - 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	923 unless exported.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	924 - When importing a script the symbols that are imported are listed, avoiding
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	925 name conflicts and failures if later functionality is added.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	926 - 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	927 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	928 - 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	929 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	930 - 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	931 avoided.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	932 - 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	933
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	934 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	935 globally can be used, not the exported items. Alternatives considered:
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	936 - All the exported items become available as script-local items. This makes
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	937 it uncontrollable what items get defined.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	938 - 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	939 not possible to avoid name clashes in the global namespace.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	940 - Completely disallow sourcing a Vim9 script, require using `:import`. That
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	941 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	942 command line to try them out.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	943
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	944
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	945 Classes ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	946
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	947 Vim supports interfaces to Perl, Python, Lua, Tcl and a few others. But
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	948 these have never become widespread. When Vim 9 was designed a decision was
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	949 made to phase out these interfaces and concentrate on Vim script, while
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	950 encouraging plugin authors to write code in any language and run it as an
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	951 external tool, using jobs and channels.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	952
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	953 Still, using an external tool has disadvantages. An alternative is to convert
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	954 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	955 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	956 tool need to be supported. Since most languages support classes the lack of
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	957 class support in Vim is then a problem.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	958
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	959 Previously Vim supported a kind-of object oriented programming by adding
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	960 methods to a dictionary. With some care this could be made to work, but it
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	961 does not look like real classes. On top of that, it's very slow, because of
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	962 the use of dictionaries.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	963
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	964 The support of classes in Vim9 script is a "minimal common functionality" of
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	965 class support in most languages. It works mostly like Java, which is the most
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	966 popular programming language.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	967
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	968
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	969
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	970 vim:tw=78:ts=8:noet:ft=help:norl:

Mercurial > vim

annotate runtime/doc/vim9.txt @ 21750:3a928a619b67