vim: runtime/doc/vim9.txt annotate

annotate runtime/doc/vim9.txt @ 22500:ef8a3177edc1 v8.2.1798

patch 8.2.1798: Vim9: trinary operator condition is too permissive Commit: https://github.com/vim/vim/commit/1310660557470a669cc64b359e20666b116e5dbd Author: Bram Moolenaar <Bram@vim.org> Date: Sun Oct 4 16:06:05 2020 +0200 patch 8.2.1798: Vim9: trinary operator condition is too permissive Problem: Vim9: trinary operator condition is too permissive. Solution: Use tv_get_bool_chk().

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 04 Oct 2020 16:15:04 +0200
parents	4c21f7f6f9e3
children	17c4178f26ea

rev	line source
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1 vim9.txt For Vim version 8.2. Last change: 2020 Sep 26
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	4 VIM REFERENCE MANUAL by Bram Moolenaar
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	7 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	8
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	9 Vim9 script commands and expressions. vim9
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	10
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	11 Most expression help is in \|eval.txt\|. This file is about the new syntax and
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	12 features in Vim9 script.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	13
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	14 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	15
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	16
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	17 1. What is Vim9 script? \|vim9-script\|
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	18 2. Differences \|vim9-differences\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	19 3. New style functions \|fast-functions\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	20 4. Types \|vim9-types\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	21 5. Namespace, Import and Export \|vim9script\|
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	22 6. Future work: classes \|vim9-classes\|
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	23
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	24 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	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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	28 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	29
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	30 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	31
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	32 Vim script has been growing over time, while preserving backwards
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	33 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	34 and compatibility with Vi restricts possible solutions. Execution is quite
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	35 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	36
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	37 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	38 accomplished by compiling commands into instructions that can be efficiently
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	39 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	40
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	41 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	42 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	43
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	44 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	45 compatible. For example, making function arguments available in the
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	46 "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	47 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	48 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	49
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	50 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	51 - 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	52 - a script file where the first command is `vim9script`
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	53 - an autocommand defined in the context of the above
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	54
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	55 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	56 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	57
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	58 Vim9 script and legacy Vim script can be mixed. There is no requirement to
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	59 rewrite old scripts, they keep working as before. You may want to use a few
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	60 `:def` functions for code that needs to be fast.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	61
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
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	64 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	65
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	66 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	67
22441 a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	68 Overview ~
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	69
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	70 Brief summary of the differences you will most often encounter when using Vim9
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	71 script and `:def` functions; details are below:
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	72 - Comments start with #, not ": >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	73 echo "hello" # comment
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	74 - Using a backslash for line continuation is hardly ever needed: >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	75 echo "hello "
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	76 .. yourName
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	77 .. ", how are you?"
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	78 - White space is required in many places.
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	79 - Assign values without `:let`, declare variables with `:var`: >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	80 var count = 0
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	81 count += 3
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	82 - Constants can be declared with `:final` and `:const`: >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	83 final matches = [] # add matches
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	84 const names = ['Betty', 'Peter'] # cannot be changed
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	85 - `:final` cannot be used as an abbreviation of `:finally`.
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	86 - Variables and functions are script-local by default.
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	87 - Functions are declared with argument types and return type: >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	88 def CallMe(count: number, message: string): bool
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	89 - Call functions without `:call`: >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	90 writefile(['done'], 'file.txt')
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	91 - You cannot use `:xit`, `:t`, `:append`, `:change`, `:insert` or curly-braces
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	92 names.
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	93 - A range before a command must be prefixed with a colon: >
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	94 :%s/this/that
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	95
a3bb84cd0f59 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22391 diff changeset	96
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	97 Comments starting with # ~
c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	98
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	99 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	100 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	101 # declarations
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	102 var count = 0 # number of occurrences
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	103
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	104 The reason is that a double quote can also be the start of a string. In many
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	105 places, especially halfway through an expression with a line break, it's hard
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	106 to tell what the meaning is, since both a string and a comment can be followed
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	107 by arbitrary text. To avoid confusion only # comments are recognized. This
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	108 is the same as in shell scripts and Python programs.
21353 fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	109
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	110 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	111 `: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	112 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	113
fb8c8fcb7b60 patch 8.2.1227: Vim9: allowing both quoted and # comments is confusing Bram Moolenaar <Bram@vim.org> parents: 21250 diff changeset	114 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	115 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	116 it does not start a comment.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	117
20023 c85d4e173cc9 patch 8.2.0567: Vim9: cannot put comments halfway expressions Bram Moolenaar <Bram@vim.org> parents: 20015 diff changeset	118
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	119 Vim9 functions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	120
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	121 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	122 often 10x to 100x times.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	123
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	124 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	125 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	126
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	127 Compilation is done when:
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	128 - the function is first called
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	129 - when the `:defcompile` command is encountered in the script where the
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	130 function was defined
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	131 - `:disassemble` is used for the function.
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	132 - a function that is compiled calls the function or uses it as a function
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	133 reference
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	134
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	135 `:def` has no options like `:function` does: "range", "abort", "dict" or
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	136 "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	137 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	138
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	139 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	140 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	141 functions.
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	142
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	143 Arguments are accessed by name, without "a:", just like any other language.
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	144 There is no "a:" dictionary or "a:000" list.
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	145
56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	146 Variable arguments are defined as the last argument, with a name and have a
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	147 list type, similar to TypeScript. For example, a list of numbers: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	148 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	149 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	150 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	151
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	152
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	153 Functions and variables are script-local by default ~
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	154 vim9-scopes
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	155 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	156 in a Vim9 script, the function is local to the script, as if "s:" was
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	157 prefixed. Using the "s:" prefix is optional. To define a global function or
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	158 variable the "g:" prefix must be used. For functions in an autoload script
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	159 the "name#" prefix is sufficient. >
21550 b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	160 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	161 def s:ThisFunction() # script-local
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	162 def g:ThatFunction() # global
21550 b0b57d91671c patch 8.2.1325: Vim9: using Vim9 script for autaload not tested Bram Moolenaar <Bram@vim.org> parents: 21516 diff changeset	163 def scriptname#function() # autoload
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	164
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	165 When using `:function` or `:def` to specify a nested function inside a `:def`
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	166 function, this nested function is local to the code block it is defined in.
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	167 In a `:def` function it is not possible to define a script-local function. it
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	168 is possible to define a global function by using the "g:" prefix.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	169
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	170 When referring to a function and no "s:" or "g:" prefix is used, Vim will
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	171 search for the function:
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	172 - in the function scope
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	173 - in the script scope, possibly imported
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	174 - in the list of global functions
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	175 However, it is recommended to always use "g:" to refer to a global function
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	176 for clarity.
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	177
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	178 In all cases the function must be defined before used. That is when it is
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	179 called, when `:defcompile` causes the it to be compiled, or when code that
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	180 calls it is being compiled (to figure out the return type).
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	181
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	182 The result is that functions and variables without a namespace can usually be
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	183 found in the script, either defined there or imported. Global functions and
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	184 variables could be defined anywhere (good luck finding out where!).
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	185
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	186 Global functions can still be defined and deleted at nearly any time. In
20317 2334bf788e8a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20241 diff changeset	187 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	188 and cannot be deleted or replaced.
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	189
bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	190
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	191 Variable declarations with :var, :final and :const ~
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	192 vim9-declaration :var
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	193 Local variables need to be declared with `:var`. Local constants need to be
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	194 declared with `:final` or `:const`. We refer to both as "variables" in this
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	195 section.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	196
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	197 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	198 vim9script
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	199 var script_var = 123
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	200 def SomeFunc()
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	201 var func_var = script_var
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	202 if cond
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	203 var block_var = func_var
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	204 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	205
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	206 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	207 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	208 if cond
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	209 var inner = 5
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	210 else
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	211 var inner = 0
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	212 endif
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	213 echo inner # Error!
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	214
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	215 The declaration must be done earlier: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	216 var inner: number
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	217 if cond
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	218 inner = 5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	219 else
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	220 inner = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	221 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	222 echo inner
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	223
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	224 To intentionally hide a variable from code that follows, a block can be
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	225 used: >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	226 {
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	227 var temp = 'temp'
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	228 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	229 }
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	230 echo temp # Error!
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	231
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	232 Declaring a variable with a type but without an initializer will initialize to
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	233 zero, false or empty.
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	234
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	235 In Vim9 script `:let` cannot be used. An existing variable is assigned to
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	236 without any command. The same for global, window, tab, buffer and Vim
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	237 variables, because they are not really declared. They can also be deleted
21584 d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	238 with `:unlet`.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	239
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	240 Variables and functions cannot shadow previously defined or imported variables
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	241 and functions.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	242 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	243
20241 56265f711890 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20115 diff changeset	244 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	245 at the script level. >
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	246 vim9script
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	247 var script_local = 'text'
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	248 g:global = 'value'
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	249 var Funcref = g:ThatFunction
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	250
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	251 Since `&opt = value` is now assigning a value to option "opt", ":&" cannot be
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	252 used to repeat a `:substitute` command.
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	253
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	254
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	255 Constants ~
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	256 vim9-const vim9-final
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	257 How constants work varies between languages. Some consider a variable that
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	258 can't be assigned another value a constant. JavaScript is an example. Others
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	259 also make the value immutable, thus when a constant uses a list, the list
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	260 cannot be changed. In Vim9 we can use both.
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	261
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	262 `:const` is used for making both the variable and the value a constant. Use
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	263 this for composite structures that you want to make sure will not be modified.
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	264 Example: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	265 const myList = [1, 2]
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	266 myList = [3, 4] # Error!
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	267 myList[0] = 9 # Error!
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	268 muList->add(3) # Error!
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	269 < :final
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	270 `:final` is used for making only the variable a constant, the value can be
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	271 changed. This is well known from Java. Example: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	272 final myList = [1, 2]
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	273 myList = [3, 4] # Error!
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	274 myList[0] = 9 # OK
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	275 muList->add(3) # OK
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	276
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	277 It is common to write constants as ALL_CAPS, but you don't have to.
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	278
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	279 The constant only applies to the value itself, not what it refers to. >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	280 final females = ["Mary"]
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	281 const NAMES = [["John", "Peter"], females]
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	282 NAMES[0] = ["Jack"] # Error!
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	283 NAMES[0][0] = "Jack" # Error!
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	284 NAMES[1] = ["Emma"] # Error!
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	285 Names[1][0] = "Emma" # OK, now females[0] == "Emma"
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	286
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	287 < E1092
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	288 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	289 currently not supported: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	290 var [v1, v2] = GetValues() # Error!
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	291 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	292 isn't that easy.
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	293
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	294
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	295 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	296
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	297 Functions can be called without `:call`: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	298 writefile(lines, 'file')
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	299 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	300
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	301 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	302 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	303 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	304 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	305 [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	306 #{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	307 {'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	308 "foobar"->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	309 ("foobar")->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	310 'foobar'->Process()
c7b2ce90c2de patch 8.2.1308: Vim9: accidentally using "x" causes Vim to exit Bram Moolenaar <Bram@vim.org> parents: 21499 diff changeset	311 ('foobar')->Process()
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	312
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	313 In the rare case there is ambiguity between a function name and an Ex command,
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	314 prepend ":" to make clear you want to use the Ex command. For example, there
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	315 is both the `:substitute` command and the `substitute()` function. When the
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	316 line starts with `substitute(` this will use the function. Prepend a colon to
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	317 use the command instead: >
19481 c27837cbe922 patch 8.2.0298: Vim9 script: cannot start command with a string constant Bram Moolenaar <Bram@vim.org> parents: 19473 diff changeset	318 :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	319
19556 ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	320 Note that while variables need to be defined before they can be used,
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	321 functions can be called before being defined. This is required to allow
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	322 for cyclic dependencies between functions. It is slightly less efficient,
19556 ff5048b0ccfe patch 8.2.0335: no completion for :disassemble Bram Moolenaar <Bram@vim.org> parents: 19523 diff changeset	323 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	324 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	325
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	326
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	327 Omitting function() ~
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	328
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	329 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	330 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	331 The function must already have been defined. >
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	332
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	333 var Funcref = MyFunction
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	334
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	335 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	336 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	337
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	338
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	339 Automatic line continuation ~
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	340
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	341 In many cases it is obvious that an expression continues on the next line. In
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	342 those cases there is no need to prefix the line with a backslash
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	343 \|line-continuation\|. For example, when a list spans multiple lines: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	344 var mylist = [
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	345 'one',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	346 'two',
844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	347 ]
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	348 And when a dict spans multiple lines: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	349 var mydict = #{
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	350 one: 1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	351 two: 2,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	352 }
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	353 Function call: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	354 var result = Func(
20011 628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	355 arg1,
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	356 arg2
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	357 )
628011800942 patch 8.2.0561: Vim9: cannot split function call in multiple lines Bram Moolenaar <Bram@vim.org> parents: 19999 diff changeset	358
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	359 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	360 possible just before or after the operator. For example: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	361 var text = lead
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	362 .. middle
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	363 .. end
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	364 var total = start +
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	365 end -
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20011 diff changeset	366 correction
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	367 var result = positive
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	368 ? 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	369 : 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	370
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	371 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	372 before it: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	373 var result = GetBuilder()
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	374 ->BuilderSetWidth(333)
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	375 ->BuilderSetHeight(777)
59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	376 ->BuilderBuild()
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	377 var result = MyDict
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	378 .member
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	379
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	380 < E1050
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	381 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	382 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	383 "start" and print: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	384 var result = start
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	385 + print
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	386 Like this: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	387 var result = start + print
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	388
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	389 This will assign "start" and print a line: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	390 var result = start
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20965 diff changeset	391 :+ print
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	392
20015 c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	393 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	394 arguments: >
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	395 def MyFunc(
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	396 text: string,
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	397 separator = '-'
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	398 ): string
c001ee73519a patch 8.2.0563: Vim9: cannot split a function line Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	399
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	400 Notes:
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	401 - "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	402 current function.
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	403 - 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	404 unpacking a list \|:let-unpack\|. This is OK: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	405 [var1, var2] =
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	406 Func()
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	407 < This does not work: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	408 [var1,
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	409 var2] =
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	410 Func()
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	411 - 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	412 similar commands. This is OK: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	413 echo [1,
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	414 2] [3,
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	415 4]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	416 < This does not work: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	417 echo [1, 2]
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	418 [3, 4]
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	419 - 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	420 "->". This is OK: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	421 filter(list, {k, v ->
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	422 v > 0})
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	423 < This does not work: >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	424 filter(list, {k,
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	425 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	426
19999 844c7646f61b patch 8.2.0555: Vim9: line continuation is not always needed Bram Moolenaar <Bram@vim.org> parents: 19968 diff changeset	427
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	428 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	429
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	430 \|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	431
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	432
21584 d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	433 No :xit, :t, :append, :change or :insert ~
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	434
21584 d0c76ce48326 patch 8.2.1342: Vim9: accidentally using "t" gives a confusing error Bram Moolenaar <Bram@vim.org> parents: 21550 diff changeset	435 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	436 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	437 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	438
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	439
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	440 Comparators ~
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	441
51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	442 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	443
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	444
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	445 White space ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	446
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	447 Vim9 script enforces proper use of white space. This is no longer allowed: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	448 var name=234 # Error!
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	449 var name= 234 # Error!
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	450 var name =234 # Error!
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	451 There must be white space before and after the "=": >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	452 var name = 234 # OK
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	453 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	454 command: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	455 var name = 234# Error!
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	456 var name = 234 # OK
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	457
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	458 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	459
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	460 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	461 - Between a function name and the "(": >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	462 call Func (arg) # Error!
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	463 call Func
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	464 \ (arg) # Error!
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	465 call Func(arg) # OK
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	466 call Func(
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	467 \ arg) # OK
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	468 call Func(
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	469 \ 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	470 \ )
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	471
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	472
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	473 Conditions and expressions ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	474
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	475 Conditions and expressions are mostly working like they do in other languages.
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	476 Some values are different from legacy Vim script:
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	477 value legacy Vim script Vim9 script ~
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	478 0 falsy falsy
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	479 1 truthy truthy
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	480 99 truthy Error!
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	481 "0" falsy Error!
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	482 "99" truthy Error!
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	483 "text" falsy Error!
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	484
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	485 For the "??" operator and when using "!" then there is no error, every value
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	486 is either falsy or truthy. This is mostly like JavaScript, except that an
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	487 empty list and dict is falsy:
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	488
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	489 type truthy when ~
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	490 bool v:true or 1
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	491 number non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	492 float non-zero
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	493 string non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	494 blob non-empty
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	495 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	496 dictionary non-empty (different from JavaScript)
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	497 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	498 special v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	499 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	500 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	501 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	502 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	503
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	504 The boolean operators "\|\|" and "&&" expect the values to be boolean, zero or
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	505 one: >
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	506 1 \|\| false == true
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	507 0 \|\| 1 == true
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	508 0 \|\| false == false
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	509 1 && true == true
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	510 0 && 1 == false
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	511 8 \|\| 0 Error!
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	512 'yes' && 0 Error!
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	513 [] \|\| 99 Error!
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	514
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	515 When using "!" for inverting, there is no error for using any type and the
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	516 result is a boolean. "!!" can be used to turn any value into boolean: >
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	517 !'yes' == false
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	518 !![] == false
ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	519 !![1, 2, 3] == true
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	520
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22441 diff changeset	521 When using "`.."` for string concatenation arguments of simple types are
22500 ef8a3177edc1 patch 8.2.1798: Vim9: trinary operator condition is too permissive Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	522 always converted to string: >
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	523 'hello ' .. 123 == 'hello 123'
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	524 'hello ' .. v:true == 'hello v:true'
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	525
21771 fcf978444298 patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes Bram Moolenaar <Bram@vim.org> parents: 21717 diff changeset	526 Simple types are string, float, special and bool. For other types \|string()\|
fcf978444298 patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes Bram Moolenaar <Bram@vim.org> parents: 21717 diff changeset	527 can be used.
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	528 false true
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	529 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	530
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	531 Indexing a string with [idx] or [idx, idx] uses character indexes instead of
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	532 byte indexes. Example: >
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	533 echo 'bár'[1]
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	534 In legacy script this results in the character 0xc3 (an illegal byte), in Vim9
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	535 script this results in the string 'á'.
0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	536
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	537
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	538 What to watch out for ~
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	539 vim9-gotchas
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	540 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	541 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	542 be made. Here is a summary of what might be unexpected.
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	543
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	544 Ex command ranges need to be prefixed with a colon. >
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	545 -> # legacy Vim: shifts the previous line to the right
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	546 ->func() # Vim9: method call in continuation line
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	547 :-> # Vim9: shifts the previous line to the right
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	548
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	549 %s/a/b # legacy Vim: substitute on all lines
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	550 x = alongname
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	551 % another # Vim9: line continuation without a backslash
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	552 :%s/a/b # Vim9: substitute on all lines
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	553 'text'->func() # Vim9: method call
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	554 :'t # legacy Vim: jump to mark m
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	555
21676 1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	556 Some Ex commands can be confused with assignments in Vim9 script: >
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	557 g:name = value # assignment
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	558 g:pattern:cmd # invalid command - ERROR
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	559 :g:pattern:cmd # :global command
1b345fb68ae3 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21584 diff changeset	560
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	561 Functions defined with `:def` compile the whole function. Legacy functions
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	562 can bail out, and the following lines are not parsed: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	563 func Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	564 if !has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	565 return
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	566 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	567 use-feature
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	568 endfunc
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	569 Vim9 functions are compiled as a whole: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	570 def Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	571 if !has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	572 return
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	573 endif
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	574 use-feature # May give compilation error
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	575 enddef
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	576 For a workaround, split it in two functions: >
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	577 func Maybe()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	578 if has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	579 call MaybyInner()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	580 endif
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	581 endfunc
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	582 if has('feature')
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	583 def MaybeInner()
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	584 use-feature
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	585 enddef
99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	586 endif
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	587 Or put the unsupported code inside an `if` with a constant expression that
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	588 evaluates to false: >
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	589 def Maybe()
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	590 if has('feature')
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	591 use-feature
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	592 endif
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	593 enddef
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	594 Note that for unrecognized commands there is no check for "\|" and a following
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	595 command. This will give an error for missing `endif`: >
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	596 def Maybe()
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	597 if has('feature') \| use-feature \| endif
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	598 enddef
21093 99a602b27e0e Runtime file updates Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	599
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	600 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	601
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	602 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	603
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	604 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	605
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	606 :def
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	607 :def[!] {name}([arguments])[: {return-type}]
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	608 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	609 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	610 matching `:enddef`.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	611
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	612 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	613 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	614
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	615 {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	616 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	617 {name}: {type}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	618 {name} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	619 {name}: {type} = {value}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	620 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	621 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	622 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	623 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	624
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	625 The function will be compiled into instructions when
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	626 called, or when `:disassemble` or `:defcompile` is
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	627 used. Syntax and type errors will be produced at that
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	628 time.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	629
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	630 It is possible to nest `:def` inside another `:def` or
3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	631 `:function` up to about 50 levels deep.
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	632
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	633 [!] is used as with `:function`. Note that
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	634 script-local functions cannot be deleted or redefined
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	635 later in Vim9 script. They can only be removed by
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	636 reloading the same script.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	637
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	638 :enddef
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	639 :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	640 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	641
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	642
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	643 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	644 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	645 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	646 legacy script, then script-local variables must be accessed with the "s:"
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	647 prefix and they do not need to exist (they can be deleted any time).
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	648
20552 74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	649 :defc :defcompile
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	650 :defc[ompile] Compile functions defined in the current script that
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	651 were not compiled yet.
74e3316c1d5a Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20379 diff changeset	652 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	653
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	654 :disa :disassemble
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	655 :disa[ssemble] {func} Show the instructions generated for {func}.
7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	656 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	657 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	658 can prepend "s:" to find script-local functions.
19404 7be3663e2f2b Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19303 diff changeset	659
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	660 Limitations ~
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	661
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	662 Local variables will not be visible to string evaluation. For example: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	663 def EvalString(): list<string>
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	664 var list = ['aa', 'bb', 'cc', 'dd']
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	665 return range(1, 2)->map('list[v:val]')
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	666 enddef
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	667
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	668 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	669 function scope. Instead, use a lambda: >
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	670 def EvalString(): list<string>
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	671 var list = ['aa', 'bb', 'cc', 'dd']
21250 21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	672 return range(1, 2)->map({ _, v -> list[v] })
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	673 enddef
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	674
21fb2a3ad3ca Update runtime files Bram Moolenaar <Bram@vim.org> parents: 21093 diff changeset	675
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	676 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	677
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	678 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	679
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	680 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	681
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	682 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	683 bool
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	684 number
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	685 float
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	686 string
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	687 blob
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	688 list<{type}>
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	689 dict<{type}>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	690 job
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	691 channel
19646 847a300aa244 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19574 diff changeset	692 func
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	693 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	694 func({type}, ...)
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	695 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	696
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	697 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	698 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	699
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	700 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	701 {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	702 void
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	703 any
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	704
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	705 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	706 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	707 memory.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	708
19904 bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	709 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	710 func any kind of function reference, no type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	711 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	712 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	713 return type
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	714 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	715 a value
19968 1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	716 func({type}): {type} function with argument type and return type
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	717 func(?{type}) function with type of optional argument, does
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	718 not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	719 func(...{type}) function with type of variable number of
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	720 arguments, does not return a value
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	721 func({type}, ?{type}, ...{type}): {type}
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	722 function with:
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	723 - type of mandatory argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	724 - type of optional argument
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	725 - type of variable number of arguments
1908e92b02fd Update runtime files Bram Moolenaar <Bram@vim.org> parents: 19904 diff changeset	726 - 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	727
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	728 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	729
bd4f91762d0f patch 8.2.0508: Vim9: func and partial types not done yet Bram Moolenaar <Bram@vim.org> parents: 19646 diff changeset	730 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	731 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	732 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	733
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	734 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	735 :type MyList list<string>
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	736 Custom types must start with a capital letter, to avoid name clashes with
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	737 builtin types added later, similarly to user functions.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	738 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	739
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	740 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	741 :class MyClass
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	742 :var mine: MyClass
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	743
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	744 :interface MyInterface
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	745 :var mine: MyInterface
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	746
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	747 :class MyTemplate<Targ>
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	748 :var mine: MyTemplate<number>
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	749 :var mine: MyTemplate<string>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	750
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	751 :class MyInterface<Targ>
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	752 :var mine: MyInterface<number>
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	753 :var mine: MyInterface<string>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	754 {not implemented yet}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	755
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	756
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	757 Variable types and type casting ~
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	758 variable-types
21717 ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	759 Variables declared in Vim9 script or in a `:def` function have a type, either
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	760 specified explicitly or inferred from the initialization.
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	761
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	762 Global, buffer, window and tab page variables do not have a specific type, the
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	763 value can be changed at any time, possibly changing the type. Therefore, in
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	764 compiled code the "any" type is assumed.
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	765
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	766 This can be a problem when the "any" type is undesired and the actual type is
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	767 expected to always be the same. For example, when declaring a list: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	768 var l: list<number> = [1, g:two]
21717 ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	769 This will give an error, because "g:two" has type "any". To avoid this, use a
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	770 type cast: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	771 var l: list<number> = [1, <number>g:two]
21717 ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	772 < type-casting
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	773 The compiled code will then check that "g:two" is a number at runtime and give
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	774 an error if it isn't. This is called type casting.
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	775
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	776 The syntax of a type cast is: "<" {type} ">". There cannot be white space
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	777 after the "<" or before the ">" (to avoid them being confused with
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	778 smaller-than and bigger-than operators).
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	779
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	780 The semantics is that, if needed, a runtime type check is performed. The
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	781 value is not actually changed. If you need to change the type, e.g. to change
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	782 it to a string, use the \|string()\| function. Or use \|str2nr()\| to convert a
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	783 string to a number.
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	784
ef3b31d510d2 patch 8.2.1408: Vim9: type casting not supported Bram Moolenaar <Bram@vim.org> parents: 21715 diff changeset	785
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	786 Type inference ~
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	787 type-inference
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	788 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	789 declaring a variable and giving it a value: >
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	790 var name = 0 # infers number type
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	791 var name = 'hello' # infers string type
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	792
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	793 The type of a list and dictionary comes from the common type of the values.
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	794 If the values all have the same type, that type is used for the list or
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	795 dictionary. If there is a mix of types, the "any" type is used. >
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	796 [1, 2, 3] list<number>
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	797 ['a', 'b', 'c'] list<string>
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21676 diff changeset	798 [1, 'x', 3] list<any>
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	799
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	800
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	801 Stricter type checking ~
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	802 type-checking
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	803 In legacy Vim script, where a number was expected, a string would be
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	804 automatically converted to a number. This was convenient for an actual number
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	805 such as "123", but leads to unexpected problems (but no error message) if the
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	806 string doesn't start with a number. Quite often this leads to hard-to-find
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	807 bugs.
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	808
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	809 In Vim9 script this has been made stricter. In most places it works just as
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	810 before, if the value used matches the expected type. There will sometimes be
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	811 an error, thus breaking backwards compatibility. For example:
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	812 - Using a number other than 0 or 1 where a boolean is expected. E1023
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	813 - Using a string value when setting a number options.
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	814 - Using a number where a string is expected. E1024
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	815
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	816 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	817
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	818 5. Namespace, Import and Export
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	819 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	820
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	821 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	822
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	823 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	824 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	825 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	826
21991 bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	827 You can cheat by using the global namespace explicitly. We will assume here
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	828 that you don't do that.
bbca88cd13d5 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21825 diff changeset	829
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	830
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	831 Namespace ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	832 :vim9script :vim9
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	833 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	834 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	835 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	836 starts with: >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	837 vim9script
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	838 var myvar = 'yes'
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	839 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	840 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	841
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	842 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	843 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	844 deleted.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	845
20115 bd021eb62e73 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20023 diff changeset	846 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	847 "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	848 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	849
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	850 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	851 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	852 :set cpo&vim
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	853 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	854 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	855
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	856
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	857 Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	858 :export :exp
21499 3a1ed539ae2a Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21353 diff changeset	859 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	860 export const EXPORTED_CONST = 1234
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	861 export var someValue = ...
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	862 export final someValue = ...
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	863 export const someValue = ...
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	864 export def MyFunc() ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	865 export class MyClass ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	866
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	867 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	868 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	869
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	870 E1042
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	871 `: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	872
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	873
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	874 Import ~
20965 59f93c2d2551 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20856 diff changeset	875 :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	876 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	877 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	878 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	879
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	880 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	881 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	882
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	883 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	884 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	885 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	886
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	887 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	888 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	889
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	890 {not implemented yet: using "This as That"}
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	891
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	892 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	893 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	894 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	895
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	896 `:import` can also be used in legacy Vim script. The imported items still
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	897 become script-local, even when the "s:" prefix is not given.
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	898
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	899 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	900 - 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	901 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	902 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	903 - 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	904 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	905 - 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	906 "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	907 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	908
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	909 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	910 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	911 :import-cycle
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	912 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	913 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	914 `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	915 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	916
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	917
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	918 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	919
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	920 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	921 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	922
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	923 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	924 an autoload script. >
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	925 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	926
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	927 < 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	928
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	929 2. In the autoload script do the actual work. You can import items from
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	930 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	931 vim9script
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	932 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	933 def searchfor#Stuff(arg: string)
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	934 var filtered = FilterFunc(arg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	935 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	936 < 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	937 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	938 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	939
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	940 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	941 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	942 vim9script
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	943 var localVar = 'local'
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	944 export def FilterFunc(arg: string): string
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	945 ...
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	946 < 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	947
21771 fcf978444298 patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes Bram Moolenaar <Bram@vim.org> parents: 21717 diff changeset	948 When compiling a `:def` function and a function in an autoload script is
fcf978444298 patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes Bram Moolenaar <Bram@vim.org> parents: 21717 diff changeset	949 encountered, the script is not loaded until the `:def` function is called.
fcf978444298 patch 8.2.1435: Vim9: always converting to string for ".." leads to mistakes Bram Moolenaar <Bram@vim.org> parents: 21717 diff changeset	950
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	951
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	952 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	953
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	954 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	955 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	956
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	957
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	958 ==============================================================================
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	959
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	960 6. Future work: classes vim9-classes
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	961
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	962 Above "class" was mentioned a few times, but it has not been implemented yet.
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	963 Most of Vim9 script can be created without this functionality, and since
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	964 implementing classes is going to be a lot of work, it is left for the future.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	965 For now we'll just make sure classes can be added later.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	966
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	967 Thoughts:
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	968 - `class` / `endclass`, everything in one file
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	969 - Class names are always CamelCase
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	970 - Single constructor
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	971 - Single inheritance with `class ThisClass extends BaseClass`
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	972 - `abstract class`
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	973 - `interface` (Abstract class without any implementation)
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	974 - `class SomeClass implements SomeInterface`
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	975 - Generics for class: `class <Tkey, Tentry>`
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	976 - Generics for function: `def <Tkey> GetLast(key: Tkey)`
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	977
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	978 Again, much of this is from TypeScript.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	979
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	980 Some things that look like good additions:
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	981 - Use a class as an interface (like Dart)
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	982 - Extend a class with methods, using an import (like Dart)
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	983
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	984 An important class that will be provided is "Promise". Since Vim is single
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	985 threaded, connecting asynchronous operations is a natural way of allowing
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	986 plugins to do their work without blocking the user. It's a uniform way to
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	987 invoke callbacks and handle timeouts and errors.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	988
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	989 ==============================================================================
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	990
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	991 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	992
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	993 The :def command ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	994
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	995 Plugin writers have asked for much faster Vim script. Investigations have
19303 51bc26d4a393 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	996 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	997 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	998 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	999 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	1000 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	1001 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	1002
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1003 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	1004 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	1005 as before, but some parts do not. A new way to define a function was
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1006 considered the best way to separate the legacy style code from Vim9 style code.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1007
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1008 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	1009 "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	1010
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1011
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1012 Type checking ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1013
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1014 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	1015 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	1016 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	1017 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	1018 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	1019 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	1020 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	1021 an "add number" instruction can be used, which is faster. The error can be
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1022 given at compile time, no error handling is needed at runtime, since adding
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1023 two numbers cannot fail.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1024
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1025 The syntax for types, using <type> for compound types, is similar to Java. It
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1026 is easy to understand and widely used. The type names are what were used in
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1027 Vim before, with some additions such as "void" and "bool".
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1028
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1029
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1030 Removing clutter and weirdness ~
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1031
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1032 Once decided that `:def` functions have different syntax than legacy functions,
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1033 we are free to add improvements to make the code more familiar for users who
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1034 know popular programming languages. In other words: remove weird things that
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1035 only Vim does.
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1036
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1037 We can also remove clutter, mainly things that were done to make Vim script
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1038 backwards compatible with the good old Vi commands.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1039
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1040 Examples:
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1041 - Drop `:call` for calling a function and `:eval` for manipulating data.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1042 - Drop using a leading backslash for line continuation, automatically figure
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1043 out where an expression ends.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1044
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1045 However, this does require that some things need to change:
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1046 - Comments start with # instead of ", to avoid confusing them with strings.
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1047 This is good anyway, it is known from several popular languages.
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1048 - Ex command ranges need to be prefixed with a colon, to avoid confusion with
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1049 expressions (single quote can be a string or a mark, "/" can be divide or a
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1050 search command, etc.).
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1051
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1052 Goal is to limit the differences. A good criteria is that when the old syntax
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1053 is accidentally used you are very likely to get an error message.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1054
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1055
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1056 Syntax and semantics from popular languages ~
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1057
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1058 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	1059 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	1060 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	1061 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	1062
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1063 For many things TypeScript is followed. It's a recent language that is
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1064 gaining popularity and has similarities with Vim script. It also has a
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1065 mix of static typing (a variable always has a known value type) and dynamic
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1066 typing (a variable can have different types, this changes at runtime). Since
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1067 legacy Vim script is dynamically typed and a lot of existing functionality
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1068 (esp. builtin functions) depends on that, while static typing allows for much
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1069 faster execution, we need to have this mix in Vim9 script.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1070
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1071 There is no intention to completely match TypeScript syntax and semantics. We
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1072 just want to take those parts that we can use for Vim and we expect Vim users
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1073 will be happy with. TypeScript is a complex language with its own history,
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1074 advantages and disadvantages. To get an idea of the disadvantages read the
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1075 book: "JavaScript: The Good Parts". Or find the article "TypeScript: the good
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1076 parts" and read the "Things to avoid" section.
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1077
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1078 People familiar with other languages (Java, Python, etc.) will also find
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1079 things in TypeScript that they do not like or do not understand. We'll try to
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1080 avoid those things.
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1081
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1082 Specific items from TypeScript we avoid:
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1083 - Overloading "+", using it both for addition and string concatenation. This
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1084 goes against legacy Vim script and often leads to mistakes. For that reason
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1085 we will keep using ".." for string concatenation. Lua also uses ".." this
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1086 way. And it allows for conversion to string for more values.
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1087 - TypeScript can use an expression like "99 \|\| 'yes'" in a condition, but
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1088 cannot assign the value to a boolean. That is inconsistent and can be
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1089 annoying. Vim recognizes an expression with && or \|\| and allows using the
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1090 result as a bool. TODO: to be reconsidered
22272 eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1091 - TypeScript considers an empty string as Falsy, but an empty list or dict as
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1092 Truthy. That is inconsistent. In Vim an empty list and dict are also
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1093 Falsy.
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1094 - TypeScript has various "Readonly" types, which have limited usefulness,
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1095 since a type cast can remove the immutable nature. Vim locks the value,
eb1f5f618c75 patch 8.2.1685: Vim9: cannot declare a constant value Bram Moolenaar <Bram@vim.org> parents: 22171 diff changeset	1096 which is more flexible, but is only checked at runtime.
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1097
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1098
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1099 Declarations ~
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1100
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1101 Legacy Vim script uses `:let` for every assignment, while in Vim9 declarations
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1102 are used. That is different, thus it's good to use a different command:
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1103 `:var`. This is used in many languages. The semantics might be slightly
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1104 different, but it's easily recognized as a declaration.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1105
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1106 Using `:const` for constants is common, but the semantics vary. Some
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1107 languages only make the variable immutable, others also make the value
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1108 immutable. Since "final" is well known from Java for only making the variable
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1109 immutable we decided to use that. And then `:const` can be used for making
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1110 both immutable. This was also used in legacy Vim script and the meaning is
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1111 almost the same.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1112
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1113 What we end up with is very similar to Dart: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1114 :var name # mutable variable and value
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1115 :final name # immutable variable, mutable value
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1116 :const name # immutable variable and value
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1117
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1118 Since legacy and Vim9 script will be mixed and global variables will be
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1119 shared, optional type checking is desirable. Also, type inference will avoid
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1120 the need for specifying the type in many cases. The TypeScript syntax fits
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1121 best for adding types to declarations: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1122 var name: string # string type is specified
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1123 ...
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1124 name = 'John'
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1125 const greeting = 'hello' # string type is inferred
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1126
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1127 This is how we put types in a declaration: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1128 var mylist: list<string>
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1129 final mylist: list<string> = ['foo']
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1130 def Func(arg1: number, arg2: string): bool
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1131
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1132 Two alternatives were considered:
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1133 1. Put the type before the name, like Dart: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1134 var list<string> mylist
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1135 final list<string> mylist = ['foo']
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1136 def Func(number arg1, string arg2) bool
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1137 2. Put the type after the variable name, but do not use a colon, like Go: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1138 var mylist list<string>
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1139 final mylist list<string> = ['foo']
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1140 def Func(arg1 number, arg2 string) bool
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1141
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1142 The first is more familiar for anyone used to C or Java. The second one
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1143 doesn't really has an advantage over the first, so let's discard the second.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1144
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1145 Since we use type inference the type can be left out when it can be inferred
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1146 from the value. This means that after `var` we don't know if a type or a name
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1147 follows. That makes parsing harder, not only for Vim but also for humans.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1148 Also, it will not be allowed to use a variable name that could be a type name,
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1149 using `var string string` is too confusing.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1150
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1151 The chosen syntax, using a colon to separate the name from the type, adds
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1152 punctuation, but it actually makes it easier to recognize the parts of a
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1153 declaration.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1154
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1155
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1156 Expressions ~
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1157
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1158 Expression evaluation was already close to what JavaScript and other languages
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1159 are doing. Some details are unexpected and can be fixed. For example how the
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1160 \|\| and && operators work. Legacy Vim script: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1161 var value = 44
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1162 ...
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1163 var result = value \|\| 0 # result == 1
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1164
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1165 Vim9 script works like JavaScript/TypeScript, keep the value: >
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1166 var value = 44
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1167 ...
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1168 var result = value \|\| 0 # result == 44
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1169
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1170 TODO: the semantics of \|\| and && need to be reconsidered.
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1171
a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1172
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1173 Import and Export ~
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1174
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1175 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	1176 are global. It is possible to make them script-local, but then they are not
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1177 available in other scripts. This defies the concept of a package that only
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1178 exports selected items and keeps the rest local.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1179
21825 0db0640e16e0 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21771 diff changeset	1180 In Vim9 script a mechanism very similar to the JavaScript import and export
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1181 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	1182 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	1183 - 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	1184 unless exported.
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1185 - When importing a script the symbols that are imported are explicitly listed,
d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1186 avoiding name conflicts and failures if functionality is added later.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1187 - 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	1188 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	1189 - 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	1190 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	1191 - 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	1192 avoided.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1193 - 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	1194
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1195 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	1196 globally can be used, not the exported items. Alternatives considered:
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1197 - All the exported items become available as script-local items. This makes
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1198 it uncontrollable what items get defined and likely soon leads to trouble.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1199 - 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	1200 not possible to avoid name clashes in the global namespace.
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1201 - Completely disallow sourcing a Vim9 script, require using `:import`. That
83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1202 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	1203 command line to try them out.
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1204 Note that you can also use `:import` in legacy Vim script, see above.
20856 83cfa1ef1bf2 Update runtime files Bram Moolenaar <Bram@vim.org> parents: 20552 diff changeset	1205
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1206
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1207 Compiling functions early ~
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1208
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1209 Functions are compiled when called or when `:defcompile` is used. Why not
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1210 compile them early, so that syntax and type errors are reported early?
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1211
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1212 The functions can't be compiled right away when encountered, because there may
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1213 be forward references to functions defined later. Consider defining functions
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1214 A, B and C, where A calls B, B calls C, and C calls A again. It's impossible
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1215 to reorder the functions to avoid forward references.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1216
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1217 An alternative would be to first scan through the file to locate items and
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1218 figure out their type, so that forward references are found, and only then
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1219 execute the script and compile the functions. This means the script has to be
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1220 parsed twice, which is slower, and some conditions at the script level, such
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1221 as checking if a feature is supported, are hard to use. An attempt was made
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1222 to see if it works, but it turned out to be impossible to make work nicely.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1223
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1224 It would be possible to compile all the functions at the end of the script.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1225 The drawback is that if a function never gets called, the overhead of
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1226 compiling it counts anyway. Since startup speed is very important, in most
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1227 cases it's better to do it later and accept that syntax and type errors are
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1228 only reported then. In case these errors should be found early, e.g. when
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1229 testing, the `:defcompile` command will help out.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1230
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1231
22391 a9fb7efa31d6 patch 8.2.1744: Vim9: using ":const!" is weird Bram Moolenaar <Bram@vim.org> parents: 22328 diff changeset	1232 Why not use an embedded language? ~
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1233
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1234 Vim supports interfaces to Perl, Python, Lua, Tcl and a few others. But
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1235 these interfaces have never become widely used, for various reasons. When
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1236 Vim9 was designed a decision was made to make these interfaces lower priority
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1237 and concentrate on Vim script.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1238
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1239 Still, plugin writers may find other languages more familiar, want to use
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1240 existing libraries or see a performance benefit. We encourage plugin authors
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1241 to write code in any language and run it as an external tool, using jobs and
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1242 channels. We can try to make this easier somehow.
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1243
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1244 Using an external tool also has disadvantages. An alternative is to convert
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1245 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	1246 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	1247 tool need to be supported. Since most languages support classes the lack of
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1248 support for classes in Vim is then a problem.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1249
22328 75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1250
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1251 Classes ~
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1252
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1253 Vim supports a kind-of object oriented programming by adding methods to a
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1254 dictionary. With some care this can be made to work, but it does not look
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1255 like real classes. On top of that, it's quite slow, because of the use of
75ff30a78189 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 22272 diff changeset	1256 dictionaries.
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1257
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1258 The support of classes in Vim9 script is a "minimal common functionality" of
22171 d4c7b3e9cd17 Update runtime files. Bram Moolenaar <Bram@vim.org> parents: 21991 diff changeset	1259 class support in most languages. It works much like Java, which is the most
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1260 popular programming language.
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1261
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1262
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1263
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1264 vim:tw=78:ts=8:noet:ft=help:norl:

Mercurial > vim

annotate runtime/doc/vim9.txt @ 22500:ef8a3177edc1 v8.2.1798