vim: runtime/doc/vim9.txt annotate

annotate runtime/doc/vim9.txt @ 20552:74e3316c1d5a

Update runtime files Commit: https://github.com/vim/vim/commit/388a5d4f20b4b64341d1604aa238cab85827b892 Author: Bram Moolenaar <Bram@vim.org> Date: Tue May 26 21:20:45 2020 +0200 Update runtime files

author	Bram Moolenaar <Bram@vim.org>
date	Tue, 26 May 2020 21:30:04 +0200
parents	7f88f6a3ed4c
children	83cfa1ef1bf2

rev	line source
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	1 vim9.txt For Vim version 8.2. Last change: 2020 May 25
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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	17 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	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
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	33 and compability with Vi restricts possible solutions. Execution is quite
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
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	67 In Vim script comments normally start with double quote. That can also be the
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	68 start of a string, thus in many places it cannot be used. In Vim9 script a
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	69 comment can also start with #. In Vi this is a command to list text with
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	70 numbers, but you can also use `:number` for that. >
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	71 let count = 0 # number of occurences
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	72
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	73 To improve readability there must be a space between the command and the #
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	74 that starts a comment. Note that #{ is the start of a dictionary, therefore
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	75 it cannot start a comment.
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	76
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	77
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	78 Vim9 functions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	79
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	80 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	81 often 10x to 100x times.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	82
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	83 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	84 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	85
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	86 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	87 `:defcompile` command is encountered in the script where the function was
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	88 defined.
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	89
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	90 `:def` has no options like `:function` does: "range", "abort", "dict" or
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	91 "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	92 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	93
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	94 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	95 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	96 functions.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	97
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	98 Arguments are accessed by name, without "a:". There is no "a:" dictionary or
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	99 "a:000" list.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	100
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	101 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	102 list type, similar to Typescript. For example, a list of numbers: >
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	103 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	104 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	105 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	106
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	107
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	108 Functions and variables are script-local by default ~
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	109
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	110 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	111 in a Vim9 script, the function is local to the script, as if "s:" was
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	112 prefixed. Using the "s:" prefix is optional.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	113
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	114 To define or use a global function or variable the "g:" prefix must be used.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	115
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	116 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	117 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	118 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	119 function, using the "g:" prefix.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	120
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	121 When referring to a function and no "s:" or "g:" prefix is used, Vim will
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	122 search for the function in this order:
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	123 - Local to the current scope and outer scopes up to the function scope.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	124 - Local to the current script file.
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	125 - Imported functions, see `:import`.
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	126 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	127 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	128
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	129 The result is that functions and variables without a namespace can always be
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	130 found in the script, either defined there or imported. Global functions and
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	131 variables could be defined anywhere (good luck finding where!).
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	132
20317 2334bf788e8a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20241 diff changeset	133 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	134 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	135 and cannot be deleted or replaced.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	136
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	137
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	138 Variable declarations with :let and :const ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	139
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	140 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	141 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	142
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	143 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	144 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	145 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	146 def SomeFunc()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	147 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	148 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	149 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	150 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	151
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	152 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	153 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	154 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	155 let inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	156 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	157 let inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	158 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	159 echo inner " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	160
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	161 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	162 let inner: number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	163 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	164 inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	165 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	166 inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	167 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	168 echo inner
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	169
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	170 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	171 >
19181 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 let temp = 'temp'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	174 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	175 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	176 echo temp " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	177
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	178 An existing variable cannot be assigned to with `:let`, since that implies a
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	179 declaration. An exception is global variables: these can be both used with
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	180 and without `:let`, because there is no rule about where they are declared.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	181
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	182 Variables cannot shadow previously defined variables.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	183 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	184
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	185 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	186 at the script level. >
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	187 vim9script
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	188 let script_local = 'text'
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	189 let g:global = 'value'
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	190 let Funcref = g:ThatFunction
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	191
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	192 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	193 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	194
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	195
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	196 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	197
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	198 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	199 writefile(lines, 'file')
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	200 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	201
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	202 A method call without `eval` is possible, so long as the start is an
19481 c27837cbe922 patch 8.2.0298: Vim9 script: cannot start command with a string constant Bram Moolenaar <Bram@vim.org> parents: 19473 diff changeset	203 identifier or can't be an Ex command. It does NOT work for string constants: >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	204 myList->add(123) " works
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	205 g:myList->add(123) " works
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	206 [1, 2, 3]->Process() " works
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	207 #{a: 1, b: 2}->Process() " works
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	208 {'a': 1, 'b': 2}->Process() " works
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	209 "foobar"->Process() " does NOT work
19481 c27837cbe922 patch 8.2.0298: Vim9 script: cannot start command with a string constant Bram Moolenaar <Bram@vim.org> parents: 19473 diff changeset	210 ("foobar")->Process() " works
c27837cbe922 patch 8.2.0298: Vim9 script: cannot start command with a string constant Bram Moolenaar <Bram@vim.org> parents: 19473 diff changeset	211 'foobar'->Process() " does NOT work
c27837cbe922 patch 8.2.0298: Vim9 script: cannot start command with a string constant Bram Moolenaar <Bram@vim.org> parents: 19473 diff changeset	212 ('foobar')->Process() " works
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	213
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	214 In case there is ambiguity between a function name and an Ex command, use ":"
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	215 to make clear you want to use the Ex command. For example, there is both the
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	216 `:substitute` command and the `substitute()` function. When the line starts
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	217 with `substitute(` this will use the function, prepend a colon to use the
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	218 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	219 :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	220
19556 ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	221 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	222 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	223 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	224 since the function has to be looked up by name. And a typo in the function
ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	225 name will only be found when the call is executed.
ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	226
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	227
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	228 Omitting function() ~
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	229
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	230 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	231 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	232 The function must already have been defined. >
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	233
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	234 let Funcref = MyFunction
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	235
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	236 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	237 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	238
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	239
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	240 Automatic line continuation ~
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	241
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	242 In many cases it is obvious that an expression continues on the next line. In
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	243 those cases there is no need to prefix the line with a backslash. For
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	244 example, when a list spans multiple lines: >
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	245 let mylist = [
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	246 'one',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	247 'two',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	248 ]
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	249 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	250 let mydict = #{
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	251 one: 1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	252 two: 2,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	253 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	254 Function call: >
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	255 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	256 arg1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	257 arg2
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	258 )
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	259
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	260 For binary operators iin expressions not in [], {} or () a line break is
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	261 possible AFTER the operators. For example: >
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	262 let text = lead ..
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	263 middle ..
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	264 end
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	265 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	266 end -
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	267 correction
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	268 let result = positive ?
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	269 PosFunc(arg) :
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	270 NegFunc(arg)
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	271
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	272 Note that "enddef" cannot be used at the start of a continuation line, it ends
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	273 the current function.
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	274
20015 c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	275 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	276 arguments: >
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	277 def MyFunc(
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	278 text: string,
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	279 separator = '-'
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	280 ): string
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	281
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	282
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	283 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	284
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	285 \|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	286
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	287
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	288 No :append, :change or :insert ~
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	289
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	290 These commands are too quickly confused with local variable names.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	291
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	292
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	293 Comparators ~
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	294
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	295 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	296
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	297
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	298 White space ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	299
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	300 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	301 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	302 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	303 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	304 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	305 let var = 234 " OK
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	306 White space must also be put before the # that starts a comment: >
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	307 let var = 234# Error!
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	308 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	309
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	310 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	311
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	312 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	313 - 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	314 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	315 call Func
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	316 \ (arg) " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	317 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	318 call Func(
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	319 \ 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	320 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	321 \ 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	322 \ )
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	323
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	324
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	325 Conditions and expressions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	326
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	327 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	328 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	329 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	330
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	331 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	332 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	333 few exceptions.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	334
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	335 type TRUE when ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	336 bool v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	337 number non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	338 float non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	339 string non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	340 blob non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	341 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	342 dictionary non-empty (different from JavaScript)
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	343 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	344 special v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	345 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	346 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	347 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	348 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	349
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	350 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	351 8 \|\| 2 == 8
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	352 0 \|\| 2 == 2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	353 0 \|\| '' == ''
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	354 8 && 2 == 2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	355 0 && 2 == 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	356 [] && 2 == []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	357
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	358 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	359 string. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	360 '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	361 '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	362
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	363 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	364
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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	368 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	369
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	370 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	371
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	372 :def
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	373 :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	374 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	375 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	376 matching `:enddef`.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	377
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	378 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	379 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	380
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	381 {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	382 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	383 {name}: {type}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	384 {name} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	385 {name}: {type} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	386 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	387 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	388 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	389 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	390
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	391 NOTE: It is possible to nest `:def` inside another
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	392 `:def`, but it is not possible to nest `:def` inside
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	393 `:function`, for backwards compatibility.
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	394
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	395 [!] is used as with `:function`. Note that in Vim9
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	396 script script-local functions cannot be deleted or
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	397 redefined.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	398
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	399 :enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	400 :enddef End of a function defined with `:def`.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	401
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	402
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	403 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	404 variables can be accessed without the "s:" prefix. They must be defined
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	405 before the function. If the script the function is defined in is legacy
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	406 script, then script-local variables must be accessed with the "s:" prefix.
b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	407
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	408 :defc :defcompile
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	409 :defc[ompile] Compile functions defined in the current script that
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	410 were not compiled yet.
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	411 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	412
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	413 :disa :disassemble
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	414 :disa[ssemble] {func} Show the instructions generated for {func}.
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	415 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	416 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	417 can prepend "s:" to find script-local functions.
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	418
19181 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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	421 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	422
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	423 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	424
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	425 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	426 bool
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	427 number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	428 float
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	429 string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	430 blob
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	431 list<{type}>
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	432 dict<{type}>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	433 job
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	434 channel
19646 847a300aa244 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19574 diff changeset	435 func
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	436 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	437 func({type}, ...)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	438 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	439
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	440 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	441 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	442
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	443 These types can be used in declarations, but no value will have this type:
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	444 {type}\|{type}
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	445 void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	446 any
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	447
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	448 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	449 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	450 memory.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	451
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	452 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	453 func any kind of function reference, no type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	454 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	455 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	456 return type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	457 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	458 a value
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	459 func({type}): {type} function with argument type and return type
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	460 func(?{type}) function with type of optional argument, does
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	461 not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	462 func(...{type}) function with type of variable number of
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	463 arguments, does not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	464 func({type}, ?{type}, ...{type}): {type}
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	465 function with:
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	466 - type of mandatory argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	467 - type of optional argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	468 - type of variable number of arguments
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	469 - 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	470
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	471 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	472
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	473 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	474 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	475 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	476
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	477 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	478 :type MyList list<string>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	479 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	480
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	481 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	482 :class MyClass
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	483 :let mine: MyClass
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	484
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	485 :interface MyInterface
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	486 :let mine: MyInterface
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 :class MyTemplate<Targ>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	489 :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	490 :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	491
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	492 :class MyInterface<Targ>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	493 :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	494 :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	495 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	496
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	497
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	498 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	499
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	500 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	501 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	502 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	503 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	504
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	505
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	506 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	507
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	508 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	509 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	510
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	511 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	512
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	513 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	514 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	515 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	516
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	517
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	518 Namespace ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	519 :vim9script :vim9
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	520 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	521 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	522 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	523 starts with: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	524 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	525 let myvar = 'yes'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	526 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	527 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	528
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	529 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	530 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	531 deleted.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	532
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	533 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	534 "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	535 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	536
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	537 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	538 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	539 :set cpo&vim
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	540 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	541 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	542
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	543
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	544 Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	545 :export :exp
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	546 Exporting one item can be written as: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	547 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	548 export let someValue = ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	549 export def MyFunc() ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	550 export class MyClass ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	551
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	552 As this suggests, only constants, variables, `:def` functions and classes can
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	553 be exported.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	554
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	555 Alternatively, an export statement can be used to export several already
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	556 defined (otherwise script-local) items: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	557 export {EXPORTED_CONST, someValue, MyFunc, MyClass}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	558
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	559
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	560 Import ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	561 :import :imp
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	562 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	563 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	564 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	565
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	566 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	567 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	568
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	569 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	570 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	571 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	572
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	573 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	574 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	575
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	576 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	577 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	578 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	579
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	580 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	581 - 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	582 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	583 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	584 - 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	585 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	586 - 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	587 "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	588 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	589
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	590 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	591 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	592 :import-cycle
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	593 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	594 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	595 `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	596 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	597
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	598
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	599 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	600
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	601 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	602 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	603
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	604 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	605 an autoload script. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	606 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	607
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	608 < 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	609
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	610 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	611 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	612 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	613 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	614 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	615 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	616 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	617 < 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	618 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	619 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	620
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	621 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	622 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	623 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	624 let localVar = 'local'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	625 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	626 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	627 < 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	628
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 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	631
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	632 If an `import` statement is used in legacy Vim script, for identifier the
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	633 script-local "s:" namespace will be used, even when "s:" is not specified.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	634
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	635
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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	638 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	639
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	640 The :def command ~
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 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	643 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	644 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	645 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	646 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	647 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	648 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	649
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	650 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	651 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	652 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	653 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	654
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	655 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	656 "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	657
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	658
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	659 Type checking ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	660
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	661 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	662 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	663 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	664 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	665 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	666 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	667 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	668 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	669 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	670
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	671 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	672 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	673 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	674
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	675
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	676 JavaScript/TypeScript syntax and semantics ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	677
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	678 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	679 different from what they are used to. To reduce this complaint popular
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	680 languages will be used as an example. At the same time, we do not want to
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	681 abandon 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	682
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	683 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	684 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	685 declarations. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	686 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	687 let name: string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	688 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	689 name = 'John'
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 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	692 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	693 \|\| 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	694 let result = 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	695 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	696 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	697
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	698 Vim9 script works like JavaScript, keep the value: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	699 let result = 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	700 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	701 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	702
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	703 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	704 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	705 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	706 uses ".." this way.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	707
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 Import and Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	710
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	711 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	712 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	713 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	714
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	715 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	716 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	717 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	718 - 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	719 unless exported.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	720 - 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	721 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	722 - 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	723 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	724 - 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	725 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	726 - 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	727 avoided.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	728 - 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	729
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	730
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	731 Classes ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	732
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	733 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	734 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	735 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	736 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	737 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	738
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	739 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	740 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	741 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	742 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	743 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	744
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	745 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	746 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	747 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	748 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	749
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	750 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	751 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	752 popular programming language.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	753
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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	756 vim:tw=78:ts=8:noet:ft=help:norl:

Mercurial > vim

annotate runtime/doc/vim9.txt @ 20552:74e3316c1d5a