vim: runtime/doc/vim9.txt annotate

annotate runtime/doc/vim9.txt @ 21584:d0c76ce48326 v8.2.1342

patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Commit: https://github.com/vim/vim/commit/f5a48010ef9e47319185f1aaac1bc6d45cd4d47a Author: Bram Moolenaar <Bram@vim.org> Date: Sat Aug 1 17:00:03 2020 +0200 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Problem: Vim9: accidentally using "x" gives a confusing error. Solution: Disallow using ":t" in Vim9 script. (issue https://github.com/vim/vim/issues/6399)

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 01 Aug 2020 17:15:03 +0200
parents	b0b57d91671c
children	1b345fb68ae3

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

Mercurial > vim

annotate runtime/doc/vim9.txt @ 21584:d0c76ce48326 v8.2.1342