INTRODUCTIONlua-intro

:lua vim.print(package.loaded)

nvim -l foo.lua [args...]

if jit then  -- code for luajitelse  -- code for plain lua 5.1end

-- Start a profiling session:require('jit.p').start('ri1', '/tmp/profile')-- Perform arbitrary tasks (use plugins, scripts, etc.) ...-- Stop the session. Profile is written to /tmp/profile.require('jit.p').stop()

:lua vim.cmd.edit(package.searchpath('jit.p', package.path))

LUA CONCEPTS AND IDIOMSlua-concepts

---@return any|nil    # result on success, nil on failure.---@return nil|string # nil on success, error message on failure.

local value = assert(fn())

local foo = function(a, b)    print("A: ", a)    print("B: ", b)end

foo(1, 2)-- ==== Result ====-- A: 1-- B: 2

foo(1)-- ==== Result ====-- A: 1-- B: nil

local func_with_opts = function(opts)    local will_do_foo = opts.foo    local filename = opts.filename    -- ...endfunc_with_opts { foo = true, filename = "hello.world" }

print(string.match("foo123bar123", "%d+"))-- 123print(string.match("foo123bar123", "[^%d]+"))-- fooprint(string.match("foo123bar123", "[abc]+"))-- baprint(string.match("foo.bar", "%.bar"))-- .bar

IMPORTING LUA MODULESlua-module-load

:echo nvim_list_runtime_paths()

foo/lua/mod.luafoo/lua/mod/init.luabar/lua/mod.luabar/lua/mod/init.luafoo/lua/mod.sofoo/lua/mod.dllbar/lua/mod.sobar/lua/mod.dll

debug.getinfo(1, 'S').source:sub(2)

COMMANDSlua-commands

:lua vim.api.nvim_command('echo "Hello, Nvim!"')

:lua print(_VERSION)

:lua =jit.version

print(string.format(    'unix time: %s', os.time()))

function! CurrentLineInfo()lua << EOFlocal linenr = vim.api.nvim_win_get_cursor(0)[1]local curline = vim.api.nvim_buf_get_lines(0, linenr - 1, linenr, false)[1]print(string.format('Line [%d] has %d bytes', linenr, #curline))EOFendfunction

:luado return string.format("%s\t%d", line:reverse(), #line):lua require"lpeg":lua -- balanced parenthesis grammar::lua bp = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }:luado if bp:match(line) then return "=>\t" .. line end

:luafile script.lua:luafile %

luaeval()lua-eval

local chunkheader = "local _A = select(1, ...) return "function luaeval (expstr, arg)    local chunk = assert(loadstring(chunkheader .. expstr, "luaeval"))    return chunk(arg) -- return typvalend

:echo luaeval('_A[1] + _A[2]', [40, 2])" 42:echo luaeval('string.match(_A, "[a-z]+")', 'XYXfoo123')" foo

:echo luaeval('math.pi'):function Rand(x,y) " random uniform between x and y:  return luaeval('(_A.y-_A.x)*math.random()+_A.x', {'x':a:x,'y':a:y}):  endfunction:echo Rand(1,10)

Vimscript v:lua interfacev:lua-call

call v:lua.func(arg1, arg2)

return func(...)

call v:lua.somemod.func(args)

return somemod.func(...)

call v:lua.require'mypack'.func(arg1, arg2)call v:lua.require'mypack.submod'.func(arg1, arg2)

function mymod.omnifunc(findstart, base)  if findstart == 1 then    return 0  else    return {'stuff', 'steam', 'strange things'}  endend-- Note: The module ("mymod") must be a Lua global, or use require() as-- shown above to access it from a package.vim.bo[buf].omnifunc = 'v:lua.mymod.omnifunc'

:eval arg1->v:lua.somemod.func(arg2)

let g:Myvar = v:lua.myfunc        " Errorcall SomeFunc(v:lua.mycallback)   " Errorlet g:foo = v:lua                 " Errorlet g:foo = v:['lua']             " Error

Lua standard moduleslua-stdlib

:lua vim.print(vim)

{  _os_proc_children = <function 1>,  _os_proc_info = <function 2>,  ...  api = {    nvim__id = <function 5>,    nvim__id_array = <function 6>,    ...  },  deepcopy = <function 106>,  gsplit = <function 107>,  ...}

:help vim.deepcopy()

VIM.UVlua-loopvim.uv

local timer = vim.uv.new_timer()timer:start(1000, 0, function()  vim.api.nvim_command('echomsg "test"')end)

local timer = vim.uv.new_timer()timer:start(1000, 0, vim.schedule_wrap(function()  vim.api.nvim_command('echomsg "test"')end))

-- Create a timer handle (implementation detail: uv_timer_t).local timer = vim.uv.new_timer()local i = 0-- Waits 1000ms, then repeats every 750ms until timer:close().timer:start(1000, 750, function()  print('timer invoked! i='..tostring(i))  if i > 4 then    timer:close()  -- Always close handles to avoid leaks.  end  i = i + 1end)print('sleeping');

local w = vim.uv.new_fs_event()local function on_change(err, fname, status)  -- Do work...  vim.api.nvim_command('checktime')  -- Debounce: stop/start.  w:stop()  watch_file(fname)endfunction watch_file(fname)  local fullpath = vim.api.nvim_call_function(    'fnamemodify', {fname, ':p'})  w:start(fullpath, {}, vim.schedule_wrap(function(...)    on_change(...) end))endvim.api.nvim_command(  "command! -nargs=1 Watch call luaeval('watch_file(_A)', expand('<args>'))")

sysctl fs.inotify.max_user_watches=494462

local function create_server(host, port, on_connect)  local server = vim.uv.new_tcp()  server:bind(host, port)  server:listen(128, function(err)    assert(not err, err)  -- Check for errors.    local sock = vim.uv.new_tcp()    server:accept(sock)  -- Accept client connection.    on_connect(sock)  -- Start reading messages.  end)  return serverendlocal server = create_server('0.0.0.0', 0, function(sock)  sock:read_start(function(err, chunk)    assert(not err, err)  -- Check for errors.    if chunk then      sock:write(chunk)  -- Echo received messages to the channel.    else  -- EOF (stream closed).      sock:close()  -- Always close handles to avoid leaks.    end  end)end)print('TCP echo-server listening on port: '..server:getsockname().port)

VIMvim.builtin

print(tostring(vim.api.nvim_get_current_line()))

{  [vim.type_idx] = vim.types.float,  [vim.val_idx] = 1.0,}

-- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)-- Returns 0 because the index is pointing at the last byte of a charactervim.str_utf_end('æ', 2)-- Returns 1 because the index is pointing at the penultimate byte of a charactervim.str_utf_end('æ', 1)

-- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)-- Returns 0 because the index is pointing at the first byte of a charactervim.str_utf_start('æ', 1)-- Returns -1 because the index is pointing at the second byte of a charactervim.str_utf_start('æ', 2)

ns = vim.api.nvim_create_namespace('my_fancy_pum')vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)  if event == 'popupmenu_show' then    local items, selected, row, col, grid = ...    print('display pum ', #items)  elseif event == 'popupmenu_select' then    local selected = ...    print('selected', selected)  elseif event == 'popupmenu_hide' then    print('FIN')  endend)

-- Wait for 100 ms, allowing other events to process.vim.wait(100)-- Wait up to 1000 ms or until `vim.g.foo` is true, at intervals of ~500 ms.vim.wait(1000, function() return vim.g.foo end, 500)-- Wait up to 100 ms or until `vim.g.foo` is true, and get the callback results.local ok, rv1, rv2, rv3 = vim.wait(100, function()  return vim.g.foo, 'a', 42, { ok = { 'yes' } }end)-- Schedule a function to set a value in 100ms. This would wait 10s if blocked, but actually-- only waits 100ms because `vim.wait` processes other events while waiting.vim.defer_fn(function() vim.g.timer_result = true end, 100)if vim.wait(10000, function() return vim.g.timer_result end) then  print('Only waiting a little bit of time!')end

LUA-VIMSCRIPT BRIDGElua-vimscript

local list = { 1, 2, 3 }vim.fn.remove(list, 0)vim.print(list)  --> "{ 1, 2, 3 }"

vim.fn[func]({...})

vim.fn['some#function']({...})

vim.g.foo = 5     -- Set the g:foo Vimscript variable.print(vim.g.foo)  -- Get and print the g:foo Vimscript variable.vim.g.foo = nil   -- Delete (:unlet) the Vimscript variable.vim.b[2].foo = 6  -- Set b:foo for buffer 2

vim.g.my_dict.field1 = 'value'  -- Does not worklocal my_dict = vim.g.my_dict   --my_dict.field1 = 'value'        -- Instead dovim.g.my_dict = my_dict         --

set wildignore=*.o,*.a,__pycache__

vim.o.wildignore = '*.o,*.a,__pycache__'

vim.opt.wildignore = { '*.o', '*.a', '__pycache__' }

vim.opt.wildignore:append { "*.pyc", "node_modules" }

vim.opt.wildignore:prepend { "new_first_value" }

vim.opt.wildignore:remove { "node_modules" }

set listchars=space:_,tab:>~

vim.o.listchars = 'space:_,tab:>~'

vim.opt.listchars = { space = '_', tab = '>~' }

echo wildignore

print(vim.o.wildignore)

vim.print(vim.opt.wildignore:get())

vim.opt.formatoptions:append('j')vim.opt.formatoptions = vim.opt.formatoptions + 'j'

vim.cmd [[set wildignore=*.pyc,*.o]]vim.print(vim.opt.wildignore:get())-- { "*.pyc", "*.o", }for _, ignore_pattern in ipairs(vim.opt.wildignore:get()) do    print("Will ignore:", ignore_pattern)end-- Will ignore: *.pyc-- Will ignore: *.o

vim.cmd [[set listchars=space:_,tab:>~]]vim.print(vim.opt.listchars:get())--  { space = "_", tab = ">~", }for char, representation in pairs(vim.opt.listchars:get()) do    print(char, "=>", representation)end

vim.cmd [[set formatoptions=njtcroql]]vim.print(vim.opt.formatoptions:get())-- { n = true, j = true, c = true, ... }local format_opts = vim.opt.formatoptions:get()if format_opts.j then    print("J is enabled!")end

vim.opt.wildignore:prepend('*.o')vim.opt.wildignore = vim.opt.wildignore ^ '*.o'

vim.opt.wildignore:remove('*.pyc')vim.opt.wildignore = vim.opt.wildignore - '*.pyc'

local bufnr = vim.api.nvim_get_current_buf()vim.bo[bufnr].buflisted = true    -- same as vim.bo.buflisted = trueprint(vim.bo.comments)print(vim.bo.baz)                 -- error: invalid key

vim.env.FOO = 'bar'print(vim.env.TERM)

vim.go.cmdheight = 4print(vim.go.columns)print(vim.go.bar)     -- error: invalid key

vim.o.cmdheight = 4print(vim.o.columns)print(vim.o.foo)     -- error: invalid key

local winid = vim.api.nvim_get_current_win()vim.wo[winid].number = true    -- same as vim.wo.number = trueprint(vim.wo.foldmarker)print(vim.wo.quux)             -- error: invalid keyvim.wo[winid][0].spell = false -- like ':setlocal nospell'

Lua module: vimlua-vim

-- Single command:vim.cmd('echo 42')-- Multiline script:vim.cmd([[  augroup my.group    autocmd!    autocmd FileType c setlocal cindent  augroup END]])-- Ex command :echo "foo". Note: string literals must be double-quoted.vim.cmd('echo "foo"')vim.cmd { cmd = 'echo', args = { '"foo"' } }vim.cmd.echo({ args = { '"foo"' } })vim.cmd.echo('"foo"')-- Ex command :write! myfile.txtvim.cmd('write! myfile.txt')vim.cmd { cmd = 'write', args = { 'myfile.txt' }, bang = true }vim.cmd.write { args = { 'myfile.txt' }, bang = true }vim.cmd.write { 'myfile.txt', bang = true }-- Ex command :vertical resize +2vim.cmd.resize({ '+2', mods = { vertical = true } })

local k = vim.keycodevim.g.mapleader = k'<bs>'

vim.paste = (function(overridden)  return function(lines, phase)    for i,line in ipairs(lines) do      -- Scrub ANSI color codes from paste input.      lines[i] = line:gsub('\27%[[0-9;mK]+', '')    end    return overridden(lines, phase)  endend)(vim.paste)

local hl_normal = vim.print(vim.api.nvim_get_hl(0, { name = 'Normal' }))

function notify_readable(_err, readable)  vim.notify("readable? " .. tostring(readable))endvim.uv.fs_access(vim.fn.stdpath("config"), "R", vim.schedule_wrap(notify_readable))

Lua module: vim.inspectorvim.inspector

vim.keymap.set('n', 'zS', vim.show_pos)

local a = vim.defaulttable()a.b.c = 1

for s in vim.gsplit(':aa::b:', ':', {plain=true}) do  print(s)end

for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do  print(('word: %s num: %s'):format(word, num))end

local t = { 1, 2, 2, 3, 3, 3 }local first = vim.list.bisect(t, 3)-- `first` is `val`'s first index if found,-- useful for existence checks.print(t[first]) -- 3local last = vim.list.bisect(t, 3, { bound = 'upper' })-- Note that `last` is 7, not 6,-- this is suitable for insertion.table.insert(t, last, 4)-- t is now { 1, 2, 2, 3, 3, 3, 4 }-- You can use lower bound and upper bound together-- to obtain the range of occurrences of `val`.-- 3 is in [first, last)for i = first, last - 1 do  print(t[i]) -- { 3, 3, 3 }end

local t = {1, 2, 2, 3, 1}vim.list.unique(t)-- t is now {1, 2, 3}local t = { {id=1}, {id=2}, {id=1} }vim.list.unique(t, function(x) return x.id end)-- t is now { {id=1}, {id=2} }

local ringbuf = vim.ringbuf(4)ringbuf:push("a")ringbuf:push("b")ringbuf:push("c")ringbuf:push("d")ringbuf:push("e")    -- overrides "a"print(ringbuf:pop()) -- returns "b"print(ringbuf:pop()) -- returns "c"-- Can be used as iterator. Pops remaining items:for val in ringbuf do  print(val)end

split(":aa::b:", ":")                   --> {'','aa','','b',''}split("axaby", "ab?")                   --> {'','x','y'}split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}

vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)  return vim.deep_equal(v, { 'b', 'c' })end, { predicate = true })-- true

vim.tbl_count({ a=1, b=2 })  --> 2vim.tbl_count({ 1, 2 })      --> 2

vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == truevim.tbl_get({ key = {}}, 'key', 'nested_key') == nil

 function vim.startswith(s, prefix)  vim.validate('s', s, 'string')  vim.validate('prefix', prefix, 'string')  -- ...end

 function user.new(name, age, hobbies)  vim.validate{    name={name, 'string'},    age={age, 'number'},    hobbies={hobbies, 'table'},  }  -- ...end

vim.validate('arg1', {'foo'}, 'table')   --> NOP (success)vim.validate('arg2', 'foo', 'string')   --> NOP (success)vim.validate('arg1', 1, 'table')   --> error('arg1: expected table, got number')vim.validate('arg1', 3, function(a) return (a % 2) == 0 end, 'even number')   --> error('arg1: expected even number, got 3')

vim.validate('arg1', {'foo'}, {'table', 'string'})vim.validate('arg2', 'foo', {'table', 'string'})-- NOP (success)vim.validate('arg1', 1, {'string', 'table'})-- error('arg1: expected string|table, got number')

Lua module: vim.base64vim.base64

Lua module: vim.filetypevim.filetype

vim.filetype.add({  extension = {    foo = 'fooscript',    bar = function(path, bufnr)      if some_condition() then        return 'barscript', function(bufnr)          -- Set a buffer variable          vim.b[bufnr].barscript_version = 2        end      end      return 'bar'    end,  },  filename = {    ['.foorc'] = 'toml',    ['/etc/foo/config'] = 'toml',  },  pattern = {    ['.*/etc/foo/.*'] = 'fooscript',    -- Using an optional priority    ['.*/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },    -- A pattern containing an environment variable    ['${XDG_CONFIG_HOME}/foo/git'] = 'git',    ['.*README.(%a+)'] = function(path, bufnr, ext)      if ext == 'md' then        return 'markdown'      elseif ext == 'rst' then        return 'rst'      end    end,  },})

vim.filetype.add {  pattern = {    ['.*'] = {      function(path, bufnr)        local content = vim.api.nvim_buf_get_lines(bufnr, 0, 1, false)[1] or ''        if vim.regex([[^#!.*\\<mine\\>]]):match_str(content) ~= nil then          return 'mine'        elseif vim.regex([[\\<drawing\\>]]):match_str(content) ~= nil then          return 'drawing'        end      end,      { priority = -math.huge },    },  },}

vim.filetype.get_option('vim', 'commentstring')

-- Using a buffer numbervim.filetype.match({ buf = 42 })-- Override the filename of the given buffervim.filetype.match({ buf = 42, filename = 'foo.c' })-- Using a filename without a buffervim.filetype.match({ filename = 'main.lua' })-- Using file contentsvim.filetype.match({ contents = {'#!/usr/bin/env bash'} })

Lua module: vim.fsvim.fs

if vim.uv.fs_stat(file) then  vim.print('file exists')end

-- List all test directories under the runtime directory.local dirs = vim.fs.find(  { 'test', 'tst', 'testdir' },  { limit = math.huge, type = 'directory', path = './runtime/' })-- Get all "lib/*.cpp" and "lib/*.hpp" files, using Lua patterns.-- Or use `vim.glob.to_lpeg(…):match(…)` for glob/wildcard matching.local files = vim.fs.find(function(name, path)  return name:match('.*%.[ch]pp$') and path:match('[/\\]lib$')end, { limit = math.huge, type = 'file' })

[[C:\Users\jdoe]]                         => "C:/Users/jdoe""~/src/neovim"                            => "/home/jdoe/src/neovim""$XDG_CONFIG_HOME/nvim/init.vim"          => "/Users/jdoe/.config/nvim/init.vim""~/src/nvim/api/../tui/./tui.c"           => "/home/jdoe/src/nvim/tui/tui.c""./foo/bar"                               => "foo/bar""foo/../../../bar"                        => "../../bar""/home/jdoe/../../../bar"                 => "/bar""C:foo/../../baz"                         => "C:../baz""C:/foo/../../baz"                        => "C:/baz"[[\\?\UNC\server\share\foo\..\..\..\bar]] => "//?/UNC/server/share/bar"

local root_dirfor dir in vim.fs.parents(vim.api.nvim_buf_get_name(0)) do  if vim.fn.isdirectory(dir .. '/.git') == 1 then    root_dir = dir    break  endendif root_dir then  print('Found git repository at', root_dir)end

vim.fs.relpath('/var', '/var/lib') -- 'lib'vim.fs.relpath('/var', '/usr/bin') -- nil

-- Find the root of a Python project, starting from file 'main.py'vim.fs.root(vim.fs.joinpath(vim.env.PWD, 'main.py'), {'pyproject.toml', 'setup.py' })-- Find the root of a git repositoryvim.fs.root(0, '.git')-- Find the parent directory containing any file with a .csproj extensionvim.fs.root(0, function(name, path)  return name:match('%.csproj$') ~= nilend)-- Find the first ancestor directory containing EITHER "stylua.toml" or ".luarc.json"; if-- not found, find the first ancestor containing ".git":vim.fs.root(0, { { 'stylua.toml', '.luarc.json' }, '.git' })

Lua module: vim.globvim.glob

Lua module: vim.hlvim.hl

autocmd TextYankPost * silent! lua vim.hl.on_yank {higroup='Visual', timeout=300}

Lua module: vim.itervim.iter

local it = vim.iter({ 1, 2, 3, 4, 5 })it:map(function(v)  return v * 3end)it:rev()it:skip(2)it:totable()-- { 9, 6, 3 }-- ipairs() is a function iterator which returns both the index (i) and the value (v)vim.iter(ipairs({ 1, 2, 3, 4, 5 })):map(function(i, v)  if i > 2 then return v endend):totable()-- { 3, 4, 5 }local it = vim.iter(vim.gsplit('1,2,3,4,5', ','))it:map(function(s) return tonumber(s) end)for i, d in it:enumerate() do  print(string.format("Column %d is %d", i, d))end-- Column 1 is 1-- Column 2 is 2-- Column 3 is 3-- Column 4 is 4-- Column 5 is 5vim.iter({ a = 1, b = 2, c = 3, z = 26 }):any(function(k, v)  return k == 'z'end)-- truelocal rb = vim.ringbuf(3)rb:push("a")rb:push("b")vim.iter(rb):totable()-- { "a", "b" }

vim.iter(ipairs(t))

vim.iter(t):enumerate()

local it = vim.iter(vim.gsplit('abc', '')):enumerate()it:next()-- 1'a'it:next()-- 2'b'it:next()-- 3'c'

local bufs = vim.iter(vim.api.nvim_list_bufs()):filter(vim.api.nvim_buf_is_loaded)

local it = vim.iter({ 3, 6, 9, 12 })it:find(12)-- 12local it = vim.iter({ 3, 6, 9, 12 })it:find(20)-- nillocal it = vim.iter({ 3, 6, 9, 12 })it:find(function(v) return v % 4 == 0 end)-- 12

vim.iter({ 1, { 2 }, { { 3 } } }):flatten():totable()-- { 1, 2, { 3 } }vim.iter({1, { { a = 2 } }, { 3 } }):flatten():totable()-- { 1, { a = 2 }, 3 }vim.iter({ 1, { { a = 2 } }, { 3 } }):flatten(math.huge):totable()-- error: attempt to flatten a dict-like table

-- Create a new table with only even valuesvim.iter({ a = 1, b = 2, c = 3, d = 4 })  :filter(function(k, v) return v % 2 == 0 end)  :fold({}, function(acc, k, v)    acc[k] = v    return acc  end) --> { b = 2, d = 4 }-- Get the "maximum" item of an iterable.vim.iter({ -99, -4, 3, 42, 0, 0, 7 })  :fold({}, function(acc, v)    acc.max = math.max(v, acc.max or v)    return acc  end) --> { max = 42 }

local it = vim.iter(vim.gsplit('abcdefg', ''))it:last()-- 'g'local it = vim.iter({ 3, 6, 9, 12, 15 })it:last()-- 15

local it = vim.iter({ 1, 2, 3, 4 }):map(function(v)  if v % 2 == 0 then    return v * 3  endend)it:totable()-- { 6, 12 }

local it = vim.iter(string.gmatch('1 2 3', '%d+')):map(tonumber)it:next()-- 1it:next()-- 2it:next()-- 3

local it = vim.iter({ 3, 6, 9, 12 })it:nth(2)-- 6it:nth(2)-- 12local it2 = vim.iter({ 3, 6, 9, 12 })it2:nth(-2)-- 9it2:nth(-2)-- 3

local it = vim.iter({ 3, 6, 9, 12 })it:peek()-- 3it:peek()-- 3it:next()-- 3

local it = vim.iter({1, 2, 3, 4})it:pop()-- 4it:pop()-- 3

local it = vim.iter({ 3, 6, 9, 12 }):rev()it:totable()-- { 12, 9, 6, 3 }

local it = vim.iter({ 1, 2, 3, 2, 1 }):enumerate()it:rfind(1)-- 51it:rfind(1)-- 11

local it = vim.iter({1, 2, 3, 4})it:rpeek()-- 4it:rpeek()-- 4it:pop()-- 4

local it = vim.iter({ 1, 2, 3, 4, 5 }):rskip(2)it:next()-- 1it:pop()-- 3

local it = vim.iter({ 3, 6, 9, 12 }):skip(2)it:next()-- 9local function pred(x) return x < 10 endlocal it2 = vim.iter({ 3, 6, 9, 12 }):skip(pred)it2:next()-- 12

local it = vim.iter({ 1, 2, 3, 4 }):take(2)it:next()-- 1it:next()-- 2it:next()-- nillocal function pred(x) return x < 2 endlocal it2 = vim.iter({ 1, 2, 3, 4 }):take(pred)it2:next()-- 1it2:next()-- nil

vim.iter(string.gmatch('100 20 50', '%d+')):map(tonumber):totable()-- { 100, 20, 50 }vim.iter({ 1, 2, 3 }):map(function(v) return v, 2 * v end):totable()-- { { 1, 2 }, { 2, 4 }, { 3, 6 } }vim.iter({ a = 1, b = 2, c = 3 }):filter(function(k, v) return v % 2 ~= 0 end):totable()-- { { 'a', 1 }, { 'c', 3 } }

Lua module: vim.jsonvim.json

vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))-- { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }

function _G.fmt_json()  local indent = vim.bo.expandtab and (' '):rep(vim.o.shiftwidth) or '\t'  local lines = vim.api.nvim_buf_get_lines(0, vim.v.lnum - 1, vim.v.lnum + vim.v.count - 1, true)  local o = vim.json.decode(table.concat(lines, '\n'))  local stringified = vim.json.encode(o, { indent = indent, sort_keys = true })  lines = vim.split(stringified, '\n')  vim.api.nvim_buf_set_lines(0, vim.v.lnum - 1, vim.v.count, true, lines)endvim.o.formatexpr = 'v:lua.fmt_json()'

Lua module: vim.keymapvim.keymap

vim.keymap.del('n', 'lhs')vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 })

-- Map "x" to a Lua function:vim.keymap.set('n', 'x', function() print('real lua function') end)-- Map "<leader>x" to multiple modes for the current buffer:vim.keymap.set({'n', 'v'}, '<leader>x', vim.lsp.buf.references, { buffer = true })-- Map <Tab> to an expression (|:map-<expr>|):vim.keymap.set('i', '<Tab>', function()  return vim.fn.pumvisible() == 1 and '<C-n>' or '<Tab>'end, { expr = true })-- Map "[%%" to a <Plug> mapping:vim.keymap.set('n', '[%%', '<Plug>(MatchitNormalMultiBackward)')

Lua module: vim.loadervim.loader

Lua module: vim.lpegvim.lpeg

local pattern = lpeg.R('az') ^ 1 * -1assert(pattern:match('hello') == 6)assert(lpeg.match(pattern, 'hello') == 6)assert(pattern:match('1 hello') == nil)

local function split (s, sep)  sep = lpeg.P(sep)  local elem = lpeg.C((1 - sep) ^ 0)  local p = elem * (sep * elem) ^ 0  return lpeg.match(p, s)endlocal a, b, c = split('a,b,c', ',')assert(a == 'a')assert(b == 'b')assert(c == 'c')

local number = lpeg.R('09') ^ 1 / tonumberlocal list = number * (',' * number) ^ 0local function add(acc, newvalue) return acc + newvalue endlocal sum = lpeg.Cf(list, add)assert(sum:match('10,30,43') == 83)

local I = lpeg.Cp()local function anywhere(p) return lpeg.P({I * p * I + 1 * lpeg.V(1)}) endlocal match_start, match_end = anywhere('world'):match('hello world!')assert(match_start == 7)assert(match_end == 12)

local function gsub (s, patt, repl)  patt = lpeg.P(patt)  patt = lpeg.Cs((patt / repl + 1) ^ 0)  return lpeg.match(patt, s)endassert(gsub('Hello, xxx!', 'xxx', 'World') == 'Hello, World!')

lpeg.locale(lpeg)local space = lpeg.space ^ 0local name = lpeg.C(lpeg.alpha ^ 1) * spacelocal sep = lpeg.S(',;') * spacelocal pair = lpeg.Cg(name * '=' * space * name) * sep ^ -1local list = lpeg.Cf(lpeg.Ct('') * pair ^ 0, rawset)local t = list:match('a=b, c = hi; next = pi')assert(t.a == 'b')assert(t.c == 'hi')assert(t.next == 'pi')local locale = lpeg.locale()assert(type(locale.digit) == 'userdata')

local pattern = lpeg.R('az') ^ 1 * -1assert(pattern:match('hello') == 6)assert(lpeg.match(pattern, 'hello') == 6)assert(pattern:match('1 hello') == nil)

local pattern = lpeg.R('az') ^ 1 * -1assert(pattern:match('hello') == 6)

local b = lpeg.P({'(' * ((1 - lpeg.S '()') + lpeg.V(1)) ^ 0 * ')'})assert(b:match('((string))') == 11)assert(b:match('(') == nil)

Lua module: vim.mpackvim.mpack

Lua module: vim.netvim.net

Lua module: vim.posvim.pos

local pos1 = vim.pos(3, 5)local pos2 = vim.pos(4, 0)-- Operators are overloaded for comparing two `vim.Pos` objects.if pos1 < pos2 then  print("pos1 comes before pos2")endif pos1 ~= pos2 then  print("pos1 and pos2 are different positions")end

local buf = vim.api.nvim_get_current_buf()local lsp_pos = {  line = 3,  character = 5}-- `buf` is mandatory, as LSP positions are always associated with a buffer.local pos = vim.pos.lsp(buf, lsp_pos, 'utf-16')

-- `buf` is required for conversion to LSP position.local buf = vim.api.nvim_get_current_buf()local pos = vim.pos(3, 5, { buf = buf })-- Convert to LSP position, you can call it in a method style.local lsp_pos = pos:lsp('utf-16')

Lua module: vim.rangevim.range

local pos1 = vim.pos(3, 5)local pos2 = vim.pos(4, 0)-- Create a range from two positions.local range1 = vim.range(pos1, pos2)-- Or create a range from four integers representing start and end positions.local range2 = vim.range(3, 5, 4, 0)-- Because `vim.Range` is end exclusive, `range1` and `range2` both represent-- a range starting at the row 3, column 5 and ending at where the row 3 ends.-- Operators are overloaded for comparing two `vim.Pos` objects.if range1 == range2 then  print("range1 and range2 are the same range")end

local buf = vim.api.nvim_get_current_buf()local lsp_range = {  ['start'] = { line = 3, character = 5 },  ['end'] = { line = 4, character = 0 }}-- `buf` is mandatory, as LSP ranges are always associated with a buffer.local range = vim.range.lsp(buf, lsp_range, 'utf-16')

-- `buf` is required for conversion to LSP range.local buf = vim.api.nvim_get_current_buf()local range = vim.range(3, 5, 4, 0, { buf = buf })-- Convert to LSP range, you can call it in a method style.local lsp_range = range:to_lsp('utf-16')

Lua module: vim.revim.re

Lua module: vim.regexvim.regex

Lua module: vim.securevim.secure

Lua module: vim.snippetvim.snippet

vim.keymap.set({ 'i', 's' }, '<Tab>', function()   if vim.snippet.active({ direction = 1 }) then     return '<Cmd>lua vim.snippet.jump(1)<CR>'   else     return '<Tab>'   end end, { desc = '...', expr = true, silent = true })

Lua module: vim.spellvim.spell

vim.spell.check("the quik brown fox")-- =>-- {--     {'quik', 'bad', 5}-- }

Lua module: vim.systemlua-vim-system

local obj = vim.system({'sleep', '10'})obj:kill('sigterm') -- sends SIGTERM to the process

local obj = vim.system({'echo', 'hello'}, { text = true })local result = obj:wait(1000) -- waits up to 1000msprint(result.code, result.signal, result.stdout, result.stderr)

local obj = vim.system({'cat'}, { stdin = true })obj:write({'hello', 'world'}) -- writes 'hello\nworld\n' to stdinobj:write(nil) -- closes stdin

local on_exit = function(obj)  print(obj.code)  print(obj.signal)  print(obj.stdout)  print(obj.stderr)end-- Runs asynchronously:vim.system({'echo', 'hello'}, { text = true }, on_exit)-- Runs synchronously:local obj = vim.system({'echo', 'hello'}, { text = true }):wait()-- { code = 0, signal = 0, stdout = 'hello\n', stderr = '' }

Lua module: vim.textvim.text

vim.text.diff('a\n', 'b\nc\n')-- =>-- @@ -1 +1,2 @@-- -a-- +b-- +cvim.text.diff('a\n', 'b\nc\n', {result_type = 'indices'})-- =>-- {--   {1, 1, 1, 2}-- }

vim.print(vim.text.indent(0, ' a\n  b\n'))

local indented, old_indent = vim.text.indent(0, ' a\n b\n')indented = vim.text.indent(old_indent + 2, indented)vim.print(indented)

local text = '  a\n  b\n 'vim.print(vim.text.indent(0, (text:gsub('\n[\t ]+\n?$', '\n'))))

Lua module: vim.uivim.ui

vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)    vim.o.shiftwidth = tonumber(input)end)

-- Asynchronous.vim.ui.open("https://neovim.io/")vim.ui.open("~/path/to/file")-- Use the "osurl" command to handle the path or URL.vim.ui.open("gh#neovim/neovim!29490", { cmd = { 'osurl' } })-- Synchronous (wait until the process exits).local cmd, err = vim.ui.open("$VIMRUNTIME")if cmd then  cmd:wait()end

vim.ui.select({ 'tabs', 'spaces' }, {    prompt = 'Select tabs or spaces:',    format_item = function(item)        return "I'd like to choose " .. item    end,}, function(choice)    if choice == 'spaces' then        vim.o.expandtab = true    else        vim.o.expandtab = false    endend)

Lua module: vim.urivim.uri

Lua module: vim.versionvim.version

local v = vim.version.parse(vim.system({'tmux', '-V'}):wait().stdout, {strict=false})if vim.version.gt(v, {3, 2, 0}) then  -- ...end

VERSION RANGE SPECversion-range

1.2.3             is 1.2.3=1.2.3            is 1.2.3>1.2.3            greater than 1.2.3<1.2.3            before 1.2.3>=1.2.3           at least 1.2.3<=1.2.3           at most 1.2.3~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)^0.0.1            is =0.0.1               (0.0.x is special)^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)^1                is >=1.0.0 <2.0.0       "compatible with 1"~1                same                    "reasonably close to 1"1.x               same1.*               same1                 same*                 any versionx                 same1.2.3 - 2.3.4     is >=1.2.3 <2.3.4Partial right: missing pieces treated as x (2.3 => 2.3.x).1.2.3 - 2.3       is >=1.2.3 <2.4.01.2.3 - 2         is >=1.2.3 <3.0.0Partial left: missing pieces treated as 0 (1.2 => 1.2.0).1.2 - 2.3.0       is 1.2.0 - 2.3.0

local r = vim.version.range('1.0.0 - 2.0.0')print(r:has('1.9.9'))       -- trueprint(r:has('2.0.0'))       -- falseprint(r:has(vim.version())) -- check against current Nvim version

local r = vim.version.range('1.0.0 - 2.0.0') -- >=1.0, <2.0print(vim.version.ge({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))

if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then  -- ...endlocal v1 = vim.version.parse('1.0.3-pre')local v2 = vim.version.parse('0.2.1')if vim.version.cmp(v1, v2) == 0 then  -- ...end

{ major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }

Lua module: vim._extuivim._extui

require('vim._extui').enable({ enable = true, -- Whether to enable or disable the UI. msg = { -- Options related to the message module.   ---@type 'cmd'|'msg' Where to place regular messages, either in the   ---cmdline or in a separate ephemeral message window.   target = 'cmd',   timeout = 4000, -- Time a message is visible in the message window. },})