vim: runtime/doc/vim9.txt annotate

annotate runtime/doc/vim9.txt @ 21406:3d55463c8156

Added tag v8.2.1253 for changeset 5324acb43fea7283351fcc624f739501e2b107e4

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 19 Jul 2020 23:15:04 +0200
parents	fb8c8fcb7b60
children	3a1ed539ae2a

rev	line source
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	1 vim9.txt For Vim version 8.2. Last change: 2020 Jul 17
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
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	33 and compatibility with Vi restricts possible solutions. Execution is quite
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	34 slow, each line is parsed every time it is executed.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	35
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	36 The main goal of Vim9 script is to drastically improve performance. This is
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	37 accomplished by compiling commands into instructions that can be efficiently
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	38 executed. An increase in execution speed of 10 to 100 times can be expected.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	39
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	40 A secondary goal is to avoid Vim-specific constructs and get closer to
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	41 commonly used programming languages, such as JavaScript, TypeScript and Java.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	42
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	43 The performance improvements can only be achieved by not being 100% backwards
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	44 compatible. For example, making function arguments available in the
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	45 "a:" dictionary adds quite a lot of overhead. In a Vim9 function this
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	46 dictionary is not available. Other differences are more subtle, such as how
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	47 errors are handled.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	48
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	49 The Vim9 script syntax and semantics are used in:
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	50 - a function defined with the `:def` command
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	51 - a script file where the first command is `vim9script`
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	52
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	53 When using `:function` in a Vim9 script file the legacy syntax is used.
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	54 However, this can be confusing and is therefore discouraged.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	55
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	56 Vim9 script and legacy Vim script can be mixed. There is no requirement to
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	57 rewrite old scripts, they keep working as before.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	58
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	59 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	60
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	61 2. Differences from legacy Vim script vim9-differences
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	62
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	63 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	64
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	65 Comments starting with # ~
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	66
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	67 In legacy Vim script comments start with double quote. In Vim9 script
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	68 comments start with #. >
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	69 # declarations
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	70 let count = 0 # number of occurrences
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	71
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	72 The reason is that a double quote can also be the start of a string. In many
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	73 places, especially halfway an expression with a line break, it's hard to tell
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	74 what the meaning is. To avoid confusion only # comments are recognized.
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	75 This is the same as in shell scripts and Python programs.
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	76
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	77 In Vi # is a command to list text with numbers. In Vim9 script you can use
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	78 `:number` for that. >
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	79 101number
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	80
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	81 To improve readability there must be a space between a command and the #
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	82 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	83 it cannot start a comment.
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	84
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	85
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	86 Vim9 functions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	87
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	88 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	89 often 10x to 100x times.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	90
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	91 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	92 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	93
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	94 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	95 `:defcompile` command is encountered in the script where the function was
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	96 defined.
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	97
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	98 `:def` has no options like `:function` does: "range", "abort", "dict" or
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	99 "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	100 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	101
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	102 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	103 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	104 functions.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	105
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	106 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	107 "a:000" list.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	108
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	109 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	110 list type, similar to Typescript. For example, a list of numbers: >
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	111 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	112 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	113 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	114
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	115
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	116 Functions and variables are script-local by default ~
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	117 vim9-scopes
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	118 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	119 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	120 prefixed. Using the "s:" prefix is optional.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	121
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	122 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	123
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	124 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	125 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	126 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	127 function, using the "g:" prefix.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	128
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	129 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	130 search for the function in this order:
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	131 - 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	132 - Local to the current script file.
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	133 - Imported functions, see `:import`.
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	134 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	135 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	136
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	137 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	138 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	139 variables could be defined anywhere (good luck finding where!).
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	140
20317 2334bf788e8a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20241 diff changeset	141 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	142 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	143 and cannot be deleted or replaced.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	144
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	145
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	146 Variable declarations with :let and :const ~
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	147 vim9-declaration
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	148 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	149 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	150
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	151 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	152 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	153 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	154 def SomeFunc()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	155 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	156 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	157 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	158 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	159
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	160 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	161 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	162 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	163 let inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	164 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	165 let inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	166 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	167 echo inner " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	168
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	169 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	170 let inner: number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	171 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	172 inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	173 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	174 inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	175 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	176 echo inner
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	177
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	178 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	179 >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	180 {
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	181 let temp = 'temp'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	182 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	183 }
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	184 echo temp " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	185
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	186 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	187 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	188 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	189
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	190 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	191 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	192
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	193 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	194 at the script level. >
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	195 vim9script
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	196 let script_local = 'text'
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	197 let g:global = 'value'
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	198 let Funcref = g:ThatFunction
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	199
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	200 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	201 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	202
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	203
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	204 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	205
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	206 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	207 writefile(lines, 'file')
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	208 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	209
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	210 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	211 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	212 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	213 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	214 [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	215 #{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	216 {'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	217 "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	218 ("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	219 '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	220 ('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	221
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	222 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	223 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	224 `: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	225 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	226 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	227 :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	228
19556 ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	229 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	230 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	231 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	232 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	233 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	234
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	235
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	236 Omitting function() ~
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	237
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	238 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	239 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	240 The function must already have been defined. >
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	241
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	242 let Funcref = MyFunction
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	243
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	244 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	245 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	246
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	247
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	248 Automatic line continuation ~
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	249
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	250 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	251 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	252 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	253 let mylist = [
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	254 'one',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	255 'two',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	256 ]
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	257 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	258 let mydict = #{
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	259 one: 1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	260 two: 2,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	261 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	262 Function call: >
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	263 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	264 arg1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	265 arg2
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	266 )
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	267
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	268 For binary operators in expressions not in [], {} or () a line break is
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	269 possible just before or after the operator. For example: >
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	270 let text = lead
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	271 .. middle
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	272 .. end
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	273 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	274 end -
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	275 correction
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	276 let result = positive
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	277 ? PosFunc(arg)
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	278 : NegFunc(arg)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	279
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	280 let result = GetBuilder()
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	281 ->BuilderSetWidth(333)
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	282 ->BuilderSetHeight(777)
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	283 ->BuilderBuild()
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	284
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	285 < E1050
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	286 To make it possible for the operator at the start of the line to be
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	287 recognized, it is required to put a colon before a range. This will add
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	288 "start" and print: >
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	289 let result = start
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	290 + print
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	291 Like this: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	292 let result = start + print
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	293
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	294 This will assign "start" and print a line: >
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	295 let result = start
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	296 :+ print
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	297
20015 c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	298 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	299 arguments: >
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	300 def MyFunc(
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	301 text: string,
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	302 separator = '-'
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	303 ): string
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	304
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	305 Notes:
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	306 - "enddef" cannot be used at the start of a continuation line, it ends the
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	307 current function.
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	308 - No line break is allowed in the LHS of an assignment. Specifically when
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	309 unpacking a list \|:let-unpack\|. This is OK: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	310 [var1, var2] =
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	311 Func()
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	312 < This does not work: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	313 [var1,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	314 var2] =
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	315 Func()
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	316 - No line break is allowed in between arguments of an `:echo`, `:execute` and
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	317 similar commands. This is OK: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	318 echo [1,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	319 2] [3,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	320 4]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	321 < This does not work: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	322 echo [1, 2]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	323 [3, 4]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	324 - No line break is allowed in the arguments of a lambda, between the "{" and
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	325 "->". This is OK: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	326 filter(list, {k, v ->
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	327 v > 0})
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	328 < This does not work: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	329 filter(list, {k,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	330 v -> v > 0})
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	331
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	332
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	333 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	334
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	335 \|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	336
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	337
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	338 No :append, :change or :insert ~
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	339
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	340 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	341
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	342
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	343 Comparators ~
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	344
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	345 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	346
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	347
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	348 White space ~
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 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	351 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	352 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	353 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	354 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	355 let var = 234 " OK
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	356 White space must also be put before the # that starts a comment after a
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	357 command: >
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	358 let var = 234# Error!
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	359 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	360
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	361 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	362
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	363 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	364 - 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	365 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	366 call Func
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	367 \ (arg) " Error!
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	368 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	369 call Func(
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	370 \ 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	371 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	372 \ 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	373 \ )
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	374
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	375
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	376 Conditions and expressions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	377
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	378 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	379 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	380 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	381
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	382 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	383 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	384 few exceptions.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	385
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	386 type TRUE when ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	387 bool v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	388 number non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	389 float non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	390 string non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	391 blob non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	392 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	393 dictionary non-empty (different from JavaScript)
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	394 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	395 special v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	396 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	397 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	398 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	399 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	400
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	401 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	402 8 \|\| 2 == 8
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	403 0 \|\| 2 == 2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	404 0 \|\| '' == ''
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	405 8 && 2 == 2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	406 0 && 2 == 0
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	407 2 && 0 == 0
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	408 [] && 2 == []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	409
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	410 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	411 string. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	412 '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	413 '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	414
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	415 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	416
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	417
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	418 What to watch out for ~
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	419 vim9-gotchas
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	420 Vim9 was designed to be closer to often used programming languages, but at the
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	421 same time tries to support the legacy Vim commands. Some compromises had to
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	422 be made. Here is a summary of what might be unexpected.
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	423
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	424 Ex command ranges need to be prefixed with a colon. >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	425 -> " legacy Vim: shifts the previous line to the right
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	426 ->func() " Vim9: method call in continuation line
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	427 :-> " Vim9: shifts the previous line to the right
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	428
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	429 %s/a/b " legacy Vim: substitute on all lines
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	430 x = alongname
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	431 % another " Vim9: line continuation without a backslash
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	432 :%s/a/b " Vim9: substitute on all lines
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	433 'text'->func() " Vim9: method call
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	434 :'t " legacy Vim: jump to mark m
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	435
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	436 Functions defined with `:def` compile the whole function. Legacy functions
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	437 can bail out, and the following lines are not parsed: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	438 func Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	439 if !has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	440 return
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	441 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	442 use-feature
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	443 endfunc
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	444 Vim9 functions are compiled as a whole: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	445 def Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	446 if !has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	447 return
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	448 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	449 use-feature " May give compilation error
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	450 enddef
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	451 For a workaround, split it in two functions: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	452 func Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	453 if has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	454 call MaybyInner()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	455 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	456 endfunc
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	457 if has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	458 def MaybeInner()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	459 use-feature
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	460 enddef
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	461 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	462
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	463 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	464
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	465 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	466
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	467 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	468
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	469 :def
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	470 :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	471 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	472 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	473 matching `:enddef`.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	474
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	475 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	476 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	477
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	478 {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	479 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	480 {name}: {type}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	481 {name} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	482 {name}: {type} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	483 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	484 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	485 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	486 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	487
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	488 The function will be compiled into instructions when
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	489 called, or when `:defcompile` is used. Syntax and
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	490 type errors will be produced at that time.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	491
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	492 NOTE: It is possible to nest `:def` inside another
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	493 `:def`, but it is not possible to nest `:def` inside
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	494 `:function`, for backwards compatibility.
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	495
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	496 [!] is used as with `:function`. Note that in Vim9
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	497 script script-local functions cannot be deleted or
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	498 redefined later in the same script.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	499
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	500 :enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	501 :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	502
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	503
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	504 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	505 variables can be accessed without the "s:" prefix. They must be defined
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	506 before the function is compiled. If the script the function is defined in is
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	507 legacy script, then script-local variables must be accessed with the "s:"
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	508 prefix.
19473 b09afbebffee patch 8.2.0294: cannot use Ex command that is also a function name Bram Moolenaar <Bram@vim.org> parents: 19404 diff changeset	509
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	510 :defc :defcompile
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	511 :defc[ompile] Compile functions defined in the current script that
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	512 were not compiled yet.
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	513 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	514
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	515 :disa :disassemble
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	516 :disa[ssemble] {func} Show the instructions generated for {func}.
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	517 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	518 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	519 can prepend "s:" to find script-local functions.
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	520
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	521 Limitations ~
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	522
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	523 Local variables will not be visible to string evaluation. For example: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	524 def EvalString(): list<string>
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	525 let list = ['aa', 'bb', 'cc', 'dd']
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	526 return range(1, 2)->map('list[v:val]')
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	527 enddef
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	528
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	529 The map argument is a string expression, which is evaluated without the
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	530 function scope. Instead, use a lambda: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	531 def EvalString(): list<string>
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	532 let list = ['aa', 'bb', 'cc', 'dd']
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	533 return range(1, 2)->map({ _, v -> list[v] })
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	534 enddef
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	535
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	536
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	537 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	538
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	539 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	540
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	541 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	542
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	543 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	544 bool
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	545 number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	546 float
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	547 string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	548 blob
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	549 list<{type}>
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	550 dict<{type}>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	551 job
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	552 channel
19646 847a300aa244 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19574 diff changeset	553 func
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	554 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	555 func({type}, ...)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	556 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	557
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	558 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	559 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	560
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	561 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	562 {type}\|{type}
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	563 void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	564 any
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	565
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	566 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	567 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	568 memory.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	569
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	570 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	571 func any kind of function reference, no type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	572 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	573 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	574 return type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	575 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	576 a value
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	577 func({type}): {type} function with argument type and return type
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	578 func(?{type}) function with type of optional argument, does
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	579 not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	580 func(...{type}) function with type of variable number of
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	581 arguments, does not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	582 func({type}, ?{type}, ...{type}): {type}
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	583 function with:
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	584 - type of mandatory argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	585 - type of optional argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	586 - type of variable number of arguments
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	587 - 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	588
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	589 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	590
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	591 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	592 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	593 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	594
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	595 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	596 :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	597 {not implemented yet}
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 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	600 :class MyClass
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	601 :let mine: MyClass
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	602
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	603 :interface MyInterface
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	604 :let mine: MyInterface
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	605
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	606 :class MyTemplate<Targ>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	607 :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	608 :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	609
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	610 :class MyInterface<Targ>
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	611 :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	612 :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	613 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	614
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	615
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	616 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	617
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	618 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	619 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	620 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	621 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	622
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	623
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	624 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	625
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	626 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	627 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	628
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	629 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	630
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	631 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	632 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	633 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	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 Namespace ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	637 :vim9script :vim9
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	638 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	639 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	640 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	641 starts with: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	642 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	643 let myvar = 'yes'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	644 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	645 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	646
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	647 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	648 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	649 deleted.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	650
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	651 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	652 "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	653 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	654
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	655 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	656 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	657 :set cpo&vim
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	658 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	659 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	660
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	661
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	662 Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	663 :export :exp
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	664 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	665 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	666 export let someValue = ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	667 export def MyFunc() ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	668 export class MyClass ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	669
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	670 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	671 be exported.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	672
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	673 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	674 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	675 export {EXPORTED_CONST, someValue, MyFunc, MyClass}
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	676 <
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	677 E1042
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	678 `:export` can only be used in Vim9 script, at the script level.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	679
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	680
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	681 Import ~
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	682 :import :imp E1094
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	683 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	684 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	685 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	686
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	687 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	688 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	689
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	690 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	691 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	692 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	693
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	694 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	695 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	696
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	697 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	698 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	699 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	700
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	701 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	702 - 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	703 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	704 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	705 - 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	706 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	707 - 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	708 "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	709 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	710
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	711 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	712 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	713 :import-cycle
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	714 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	715 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	716 `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	717 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	718
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	719
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	720 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	721
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	722 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	723 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	724
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	725 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	726 an autoload script. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	727 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	728
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	729 < 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	730
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	731 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	732 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	733 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	734 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	735 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	736 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	737 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	738 < 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	739 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	740 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	741
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	742 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	743 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	744 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	745 let localVar = 'local'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	746 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	747 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	748 < 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	749
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	750
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	751 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	752
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	753 If an `import` statement is used in legacy Vim script, the script-local "s:"
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	754 namespace will be used for the imported item, even when "s:" is not specified.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	755
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	756
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	757 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	758
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	759 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	760
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	761 The :def command ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	762
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	763 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	764 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	765 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	766 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	767 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	768 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	769 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	770
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	771 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	772 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	773 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	774 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	775
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	776 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	777 "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	778
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	779
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	780 Type checking ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	781
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	782 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	783 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	784 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	785 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	786 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	787 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	788 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	789 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	790 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	791
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	792 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	793 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	794 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	795
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	796
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	797 Compiling functions early ~
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	798
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	799 Functions are compiled when called or when `:defcompile` is used. Why not
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	800 compile them early, so that syntax and type errors are reported early?
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	801
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	802 The functions can't be compiled right away when encountered, because there may
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	803 be forward references to functions defined later. Consider defining functions
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	804 A, B and C, where A calls B, B calls C, and C calls A again. It's impossible
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	805 to reorder the functions to avoid forward references.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	806
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	807 An alternative would be to first scan through the file to locate items and
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	808 figure out their type, so that forward references are found, and only then
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	809 execute the script and compile the functions. This means the script has to be
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	810 parsed twice, which is slower, and some conditions at the script level, such
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	811 as checking if a feature is supported, are hard to use. An attempt was made
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	812 to see if it works, but it turned out to be impossible to make work nicely.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	813
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	814 It would be possible to compile all the functions at the end of the script.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	815 The drawback is that if a function never gets called, the overhead of
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	816 compiling it counts anyway. Since startup speed is very important, in most
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	817 cases it's better to do it later and accept that syntax and type errors are
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	818 only reported then. In case these errors should be found early, e.g. when
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	819 testing, the `:defcompile` command will help out.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	820
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	821
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	822 TypeScript syntax and semantics ~
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	823
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	824 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	825 different from what they are used to. To reduce this complaint popular
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	826 languages are used as an example. At the same time, we do not want to abandon
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	827 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	828
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	829 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	830 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	831 declarations. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	832 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	833 let name: string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	834 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	835 name = 'John'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	836
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	837 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	838 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	839 \|\| 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	840 let result = 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	841 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	842 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	843
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	844 Vim9 script works like JavaScript/Typescript, keep the value: >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	845 let result = 44
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	846 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	847 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	848
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	849 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	850 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	851 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	852 uses ".." this way.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	853
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	854
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	855 Import and Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	856
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	857 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	858 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	859 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	860
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	861 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	862 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	863 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	864 - 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	865 unless exported.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	866 - 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	867 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	868 - 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	869 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	870 - 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	871 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	872 - 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	873 avoided.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	874 - 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	875
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	876 When sourcing a Vim9 script from a legacy script, only the items defined
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	877 globally can be used, not the exported items. Alternatives considered:
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	878 - All the exported items become available as script-local items. This makes
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	879 it uncontrollable what items get defined.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	880 - Use the exported items and make them global. Disadvantage is that it's then
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	881 not possible to avoid name clashes in the global namespace.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	882 - Completely disallow sourcing a Vim9 script, require using `:import`. That
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	883 makes it difficult to use scripts for testing, or sourcing them from the
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	884 command line to try them out.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	885
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	886
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	887 Classes ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	888
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	889 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	890 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	891 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	892 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	893 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	894
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	895 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	896 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	897 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	898 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	899 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	900
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	901 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	902 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	903 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	904 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	905
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	906 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	907 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	908 popular programming language.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	909
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	910
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	911
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	912 vim:tw=78:ts=8:noet:ft=help:norl:

Mercurial > vim

annotate runtime/doc/vim9.txt @ 21406:3d55463c8156