5]
<
If they are |Dictionaries|:
Add all entries from {expr2} to {expr1}.
If a key exists in both {expr1} and {expr2} then {expr3} is
used to decide what to do:
{expr3} = "keep": keep the value of {expr1}
{expr3} = "force": use the value of {expr2}
{expr3} = "error": give an error message *E737*
When {expr3} is omitted then "force" is assumed.
{expr1} is changed when {expr2} is not empty. If necessary
make a copy of {expr1} first or use |extendnew()| to return a
new List/Dictionary.
{expr2} remains unchanged.
When {expr1} is locked and {expr2} is not empty the operation
fails.
Returns {expr1}. Returns 0 on error.
Parameters: ~
• {expr1} (`table`)
• {expr2} (`table`)
• {expr3} (`table?`)
Return: ~
(`any`)
extendnew({expr1}, {expr2} [, {expr3}]) *extendnew()*
Like |extend()| but instead of adding items to {expr1} a new
List or Dictionary is created and returned. {expr1} remains
unchanged.
Parameters: ~
• {expr1} (`table`)
• {expr2} (`table`)
• {expr3} (`table?`)
Return: ~
(`any`)
feedkeys({string} [, {mode}]) *feedkeys()*
Characters in {string} are queued for processing as if they
come from a mapping or were typed by the user.
By default the string is added to the end of the typeahead
buffer, thus if a mapping is still being executed the
characters come after them. Use the 'i' flag to insert before
other characters, they will be executed next, before any
characters from a mapping.
The function does not wait for processing of keys contained in
{string}.
To include special keys into {string}, use double-quotes
and "\..." notation |expr-quote|. For example,
feedkeys("\<CR>") simulates pressing of the <Enter> key. But
feedkeys('\<CR>') pushes 5 characters.
The |<Ignore>| keycode may be used to exit the
wait-for-character without doing anything.
{mode} is a String, which can contain these character flags:
'm' Remap keys. This is default. If {mode} is absent,
keys are remapped.
'n' Do not remap keys.
't' Handle keys as if typed; otherwise they are handled as
if coming from a mapping. This matters for undo,
opening folds, etc.
'L' Lowlevel input. Other flags are not used.
'i' Insert the string instead of appending (see above).
'x' Execute commands until typeahead is empty. This is
similar to using ":normal!". You can call feedkeys()
several times without 'x' and then one time with 'x'
(possibly with an empty {string}) to execute all the
typeahead. Note that when Vim ends in Insert mode it
will behave as if <Esc> is typed, to avoid getting
stuck, waiting for a character to be typed before the
script continues.
Note that if you manage to call feedkeys() while
executing commands, thus calling it recursively, then
all typeahead will be consumed by the last call.
'!' When used with 'x' will not end Insert mode. Can be
used in a test when a timer is set to exit Insert mode
a little later. Useful for testing CursorHoldI.
Return value is always 0.
Parameters: ~
• {string} (`string`)
• {mode} (`string?`)
Return: ~
(`any`)
filecopy({from}, {to}) *filecopy()*
Copy the file pointed to by the name {from} to {to}. The
result is a Number, which is |TRUE| if the file was copied
successfully, and |FALSE| when it failed.
If a file with name {to} already exists, it will fail.
Note that it does not handle directories (yet).
This function is not available in the |sandbox|.
Parameters: ~
• {from} (`string`)
• {to} (`string`)
Return: