WIP

references https://github.com/nanotee/nvim-lua-guide/issues/105

README.md

@@ -396,9 +396,10 @@ Neovim exposes a global `vim` variable which serves as an entry point to interac
 
 Some notable functions and modules include:
 
-- `vim.inspect`: pretty-print Lua objects (useful for inspecting tables)
+- `vim.inspect`: transform Lua objects into human-readable strings (useful for inspecting tables)
 - `vim.regex`: use Vim regexes from Lua
 - `vim.api`: module that exposes API functions (the same API used by remote plugins)
+- `vim.ui`: overridable UI functions that can be leveraged by plugins
 - `vim.loop`: module that exposes the functionality of Neovim's event-loop (using LibUV)
 - `vim.lsp`: module that controls the built-in LSP client
 - `vim.treesitter`: module that exposes the functionality of the tree-sitter library
@@ -407,7 +408,7 @@ This list is by no means comprehensive. If you wish to know more about what's ma
 
 #### Tips
 
-Writing `print(vim.inspect(x))` every time you want to inspect the contents of an object can get pretty tedious. It might be worthwhile to have a global wrapper function somewhere in your configuration:
+Writing `print(vim.inspect(x))` every time you want to inspect the contents of an object can get pretty tedious. It might be worthwhile to have a global wrapper function somewhere in your configuration (in Neovim 0.7.0+, this function is built-in, see [`:help vim.pretty_print()`](https://neovim.io/doc/user/lua.html#vim.pretty_print())):
 
 ```lua
 function _G.put(...)
@@ -583,6 +584,14 @@ end
 vim.api.nvim_set_keymap('i', '<Tab>', 'v:lua.smart_tab()', {expr = true, noremap = true})
 ```
 
+This is not necessary with `vim.keymap.set()` as it automatically transforms vim keycodes returned by Lua functions in `expr` mappings by default:
+
+```lua
+vim.keymap.set('i', '<Tab>', function()
+    return vim.fn.pumvisible() == 1 and '<C-n>' or '<Tab>'
+end, {expr = true})
+```
+
 See also:
 
 - [`:help keycodes`](https://neovim.io/doc/user/intro.html#keycodes)
@@ -641,15 +650,15 @@ print(vim.api.nvim_buf_get_option(10, 'shiftwidth')) -- 4
 
 A few meta-accessors are available if you want to set options in a more "idiomatic" way. They essentially wrap the above API functions and allow you to manipulate options as if they were variables:
 
-- [`vim.o`](https://neovim.io/doc/user/lua.html#vim.o): behaves like `:set`
-- [`vim.go`](https://neovim.io/doc/user/lua.html#vim.go): behaves like `:setglobal`
-- [`vim.bo`](https://neovim.io/doc/user/lua.html#vim.bo): behaves like `:setlocal` for buffer-local options
-- [`vim.wo`](https://neovim.io/doc/user/lua.html#vim.wo): behaves like `:setlocal` for window-local options
+- [`vim.o`](https://neovim.io/doc/user/lua.html#vim.o): behaves like `:let &{option-name}`
+- [`vim.go`](https://neovim.io/doc/user/lua.html#vim.go): behaves like `:let &g:{option-name}`
+- [`vim.bo`](https://neovim.io/doc/user/lua.html#vim.bo): behaves like `:let &l:{option-name}` for buffer-local options
+- [`vim.wo`](https://neovim.io/doc/user/lua.html#vim.wo): behaves like `:let &l:{option-name}` for window-local options
 
 ```lua
-vim.o.smarttab = false
+vim.o.smarttab = false -- let &smarttab = v:false
 print(vim.o.smarttab) -- false
-vim.o.isfname = vim.o.isfname .. ',@-@' -- on Linux: set isfname+=@-@
+vim.o.isfname = vim.o.isfname .. ',@-@' -- on Linux: let &isfname = &isfname .. ',@-@'
 print(vim.o.isfname) -- '@,48-57,/,.,-,_,+,,,#,$,%,~,=,@-@'
 
 vim.bo.shiftwidth = 4
@@ -867,6 +876,8 @@ end
 
 ## Defining mappings
 
+### API functions
+
 Neovim provides a list of API functions to set, get and delete mappings:
 
 - Global mappings:
@@ -900,7 +911,7 @@ The second argument is a string containing the left-hand side of the mapping (th
 
 The third argument is a string containing the right-hand side of the mapping (the command to execute).
 
-The final argument is a table containing boolean options for the mapping as defined in [`:help :map-arguments`](https://neovim.io/doc/user/map.html#:map-arguments) (including `noremap` and excluding `buffer`).
+The final argument is a table containing boolean options for the mapping as defined in [`:help :map-arguments`](https://neovim.io/doc/user/map.html#:map-arguments) (including `noremap` and excluding `buffer`). Since Neovim 0.7.0, you can also pass a `callback` option to invoke a Lua function instead of the right-hand side when executing the mapping.
 
 Buffer-local mappings also take a buffer number as their first argument (`0` sets the mapping for the current buffer).
 
@@ -912,6 +923,15 @@ vim.api.nvim_set_keymap('n', '<Leader>tegf',  [[<Cmd>lua require('telescope.buil
 
 vim.api.nvim_buf_set_keymap(0, '', 'cc', 'line(".") == 1 ? "cc" : "ggcc"', { noremap = true, expr = true })
 -- :noremap <buffer> <expr> cc line('.') == 1 ? 'cc' : 'ggcc'
+
+vim.api.nvim_set_keymap('n', '<Leader>ex', '', {
+    noremap = true,
+    callback = function()
+        print('My example')
+    end,
+    -- Since Lua function don't have a useful string representation, you can use the "desc" option to document your mapping
+    desc = 'Prints "My example" in the message area',
+})
 ```
 
 `vim.api.nvim_get_keymap()` takes a string containing the shortname of the mode for which you want the list of mappings (see table above). The return value is a table containing all global mappings for the mode.
@@ -942,35 +962,141 @@ vim.api.nvim_buf_del_keymap(0, 'i', '<Tab>')
 -- :iunmap <buffer> <Tab>
 ```
 
+### vim.keymap
+
+**TODO**
+
 ## Defining user commands
 
-The interface to create user commands was implemented in the PR below and is currently available only in neovim 0.7+ (nightly):
+:warning: The API functions discussed in this section are only available in Neovim 0.7.0+
 
-- [Pull request #16752](https://github.com/neovim/neovim/pull/16752)
+Neovim provides API functions for user-defined commands:
 
-- Global user command:
-  - [`nvim_add_user_command()`](https://neovim.io/doc/user/api.html#nvim_add_user_command())
-  - [`nvim_del_user_command()`](https://neovim.io/doc/user/api.html#nvim_del_user_command())
+- Global user commands:
+    - [`vim.api.nvim_create_user_command()`](https://neovim.io/doc/user/api.html#nvim_create_user_command())
+    - [`vim.api.nvim_del_user_command()`](https://neovim.io/doc/user/api.html#nvim_del_user_command())
 - Buffer-local user commands:
-  - [`nvim_buf_add_user_command()`](https://neovim.io/doc/user/api.html#nvim_buf_add_user_command())
-  - [`nvim_buf_del_user_command()`](https://neovim.io/doc/user/api.html#nvim_buf_del_user_command())
+    - [`vim.api.nvim_buf_create_user_command()`](https://neovim.io/doc/user/api.html#nvim_buf_create_user_command())
+    - [`vim.api.nvim_buf_del_user_command()`](https://neovim.io/doc/user/api.html#nvim_buf_del_user_command())
+
+Let's start with `vim.api.nvim_create_user_command()`
+
+The first argument passed to this function is the name of the command (which must start with an uppercase letter).
+
+The second argument is the code to execute when invoking said command. It can either be:
+
+A string (in which case it will be executed as Vimscript). You can use escape sequences like `<q-args>`, `<range>`, etc. like you would with `:command`
+```lua
+vim.api.nvim_create_user_command('Upper', 'echo toupper(<q-args>)', { nargs = 1 })
+-- :command! -nargs=1 Upper echo toupper(<q-args>)
+
+vim.cmd('Upper hello world') -- prints "HELLO WORLD"
+```
+
+Or a Lua function. It receives a dictionary-like table that contains the data normally provided by escape sequences (see [`:help nvim_create_user_command()`](https://neovim.io/doc/user/api.html#nvim_create_user_command()) for a list of available keys)
+```lua
+vim.api.nvim_create_user_command(
+    'Upper',
+    function(opts)
+        print(string.upper(opts.args))
+    end,
+    { nargs = 1 }
+)
+```
+
+The third argument lets you pass command attributes as a table (see [`:help command-attributes`](https://neovim.io/doc/user/map.html#command-attributes)). Since you can already define buffer-local user commands with `vim.api.nvim_buf_create_user_command()`, `-buffer` is not a valid attribute.
+
+Two additional attributes are available:
+- `desc` allows you to control what gets displayed when you run `:command {cmd}` on a command defined as a Lua callback.
+- `force` is equivalent to calling `:command!` and replaces a command if one with the same name already exists. It is true by default, unlike its Vimscript equivalent.
+
+The `-complete` attribute can take a Lua function in addition to the attributes listed in [`:help :command-complete`](https://neovim.io/doc/user/map.html#:command-complete).
+
+```lua
+vim.api.nvim_create_user_command('Upper', function() end, {
+    nargs = 1,
+    complete = function(ArgLead, CmdLine, CursorPos)
+        -- return completion candidates as a list-like table
+        return { 'foo', 'bar', 'baz' }
+    end,
+})
+```
+
+Buffer-local user commands also take a buffer number as their first argument. This is an advantage over `-buffer` which can only define a command for the current buffer.
+
+```lua
+vim.api.nvim_buf_create_user_command(4, 'Upper', function() end, {})
+```
+
+`vim.api.nvim_del_user_command()` takes a command name.
+
+```lua
+vim.api.nvim_del_user_command('Upper')
+-- :delcommand Upper
+```
+
+Again, `vim.api.nvim_buf_del_user_command()`, takes a buffer number as its first argument, with `0` representing the current buffer.
+
+```lua
+vim.api.nvim_buf_del_user_command(4, 'Upper')
+```
+
+See also:
+- [`:help nvim_create_user_command()`](https://neovim.io/doc/user/api.html#nvim_create_user_command())
+- [`:help 40.2`](https://neovim.io/doc/user/usr_40.html#40.2)
+- [`:help command-attributes`](https://neovim.io/doc/user/map.html#command-attributes)
+
+### Caveats
+
+The `-complete=custom` attribute automatically filters completion candidates and has built-in wildcard ([`:help wildcard`](https://neovim.io/doc/user/editing.html#wildcard)) support:
+
+```vim
+function! s:completion_function(ArgLead, CmdLine, CursorPos) abort
+    return join([
+        \ 'strawberry',
+        \ 'star',
+        \ 'stellar',
+        \ ], "\n")
+endfunction
+
+command! -nargs=1 -complete=custom,s:completion_function Test echo <q-args>
+" Typing `:Test st[ae]<Tab>` returns "star" and "stellar"
+```
+
+Passing a Lua function to `complete` makes it behave like `customlist` which leaves filtering up to the user:
+
+```lua
+vim.api.nvim_create_user_command('Test', function() end, {
+    nargs = 1,
+    complete = function(ArgLead, CmdLine, CursorPos)
+        return {
+            'strawberry',
+            'star',
+            'stellar',
+        }
+    end,
+})
+
+-- Typing `:Test z<Tab>` returns all the completion results because the list was not filtered
+```
 
 ## Defining autocommands
 
-Augroups and autocommands do not have an interface yet but it is being worked on:
+(this section is a work in progress)
+
+Neovim 0.7.0 has API functions for autocommands. See `:help api-autocmd` for details
 
-- [Pull request #12378](https://github.com/neovim/neovim/pull/12378)
 - [Pull request #14661](https://github.com/neovim/neovim/pull/14661) (lua: autocmds take 2)
 
-In the meantime, you can either create autocommands in Vimscript or use [this wrapper from norcalli/nvim_utils](https://github.com/norcalli/nvim_utils/blob/master/lua/nvim_utils.lua#L554-L567)
+## Defining highlights
 
-## Defining syntax/highlights
+(this section is a work in progress)
 
-The syntax API is still a work in progress. Here are a couple of pointers:
+Neovim 0.7.0 has API functions for highlight groups. See also:
 
-- [Issue #9876](https://github.com/neovim/neovim/issues/9876)
-- [tjdevries/colorbuddy.vim, a library for creating colorschemes in Lua](https://github.com/tjdevries/colorbuddy.vim)
-- [`:help lua-treesitter`](https://neovim.io/doc/user/treesitter.html#lua-treesitter)
+- [`:help nvim_set_hl()`](https://neovim.io/doc/user/api.html#nvim_set_hl())
+- [`:help nvim_get_hl_by_id()`](https://neovim.io/doc/user/api.html#nvim_get_hl_by_id())
+- [`:help nvim_get_hl_by_name()`](https://neovim.io/doc/user/api.html#nvim_get_hl_by_name())
 
 ## General tips and recommendations
 
@@ -1117,6 +1243,30 @@ You can debug Lua code running in a separate Neovim instance with [jbyuki/one-sm
 
 The plugin uses the [Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/). Connecting to a debug adapter requires a DAP client like [mfussenegger/nvim-dap](https://github.com/mfussenegger/nvim-dap/) or [puremourning/vimspector](https://github.com/puremourning/vimspector/).
 
+### Debugging Lua mappings/commands/autocommands
+
+The `:verbose` command allows you to see where a mapping/command/autocommand was defined:
+
+```vim
+:verbose map m
+```
+
+```text
+n  m_          * <Cmd>echo 'example'<CR>
+        Last set from ~/.config/nvim/init.vim line 26
+```
+
+By default, this feature is disabled in Lua for performance reasons. You can enable it by starting Neovim with a verbose level greater than 0:
+
+```sh
+nvim -V1
+```
+
+See also:
+- [`:help 'verbose'`](https://neovim.io/doc/user/options.html#'verbose')
+- [`:help -V`](https://neovim.io/doc/user/starting.html#-V)
+- [neovim/neovim#15079](https://github.com/neovim/neovim/pull/15079)
+
 ### Testing Lua code
 
 - [plenary.nvim: test harness](https://github.com/nvim-lua/plenary.nvim/#plenarytest_harness)
@@ -1174,9 +1324,12 @@ Probably one of the most well-known transpilers for Lua. Adds a lots of convenie
 
 A lisp that compiles to Lua. You can write configuration and plugins for Neovim in Fennel with the [Olical/aniseed](https://github.com/Olical/aniseed) or the [Hotpot](https://github.com/rktjmp/hotpot.nvim) plugin. Additionally, the [Olical/conjure](https://github.com/Olical/conjure) plugin provides an interactive development environment that supports Fennel (among other languages).
 
+- [Teal](https://github.com/teal-language/tl)
+
+The name Teal comes from pronouncing TL (typed lua).  This is exactly what it tries to do - add strong typing to lua while otherwise remaining close to standard lua syntax.  The [nvim-teal-maker](https://github.com/svermeulen/nvim-teal-maker) plugin can be used to write Neovim plugins or configuration files directly in Teal
+
 Other interesting projects:
 - [TypeScriptToLua/TypeScriptToLua](https://github.com/TypeScriptToLua/TypeScriptToLua)
-- [teal-language/tl](https://github.com/teal-language/tl)
 - [Haxe](https://haxe.org/)
 - [SwadicalRag/wasm2lua](https://github.com/SwadicalRag/wasm2lua)
 - [hengestone/lua-languages](https://github.com/hengestone/lua-languages)

doc/nvim-lua-guide.txt

@@ -483,10 +483,12 @@ to interact with its APIs from Lua. It provides users with an extended
 
 Some notable functions and modules include:
 
-- `vim.inspect`: pretty-print Lua objects (useful for inspecting tables)
+- `vim.inspect`: transform Lua objects into human-readable strings
+(useful for inspecting tables)
 - `vim.regex`: use Vim regexes from Lua
 - `vim.api`: module that exposes API functions (the same API used by
 remote plugins)
+- `vim.ui`: overridable UI functions that can be leveraged by plugins
 - `vim.loop`: module that exposes the functionality of Neovim's event-loop
 (using LibUV)
 - `vim.lsp`: module that controls the built-in LSP client
@@ -501,8 +503,9 @@ of every module. API functions are documented under |api-global|.
 Tips~
 
 Writing `print(vim.inspect(x))` every time you want to inspect the
-contents of an object can get pretty tedious. It might be worthwhile to
-have a global wrapper function somewhere in your configuration:
+contents of an object can get pretty tedious. It might be worthwhile
+to have a global wrapper function somewhere in your configuration (in
+Neovim 0.7.0+, this function is built-in, see |vim.pretty_print()|):
 
     >
     function _G.put(...)
@@ -775,15 +778,16 @@ A few meta-accessors are available if you want to set options in a more
 "idiomatic" way. They essentially wrap the above API functions and allow
 you to manipulate options as if they were variables:
 
-- |vim.o|: behaves like `:set`
-- |vim.go|: behaves like `:setglobal`
-- |vim.bo|: behaves like `:setlocal` for buffer-local options
-- |vim.wo|: behaves like `:setlocal` for window-local options
+- |vim.o|: behaves like `:let &{option-name}`
+- |vim.go|: behaves like `:let &g:{option-name}`
+- |vim.bo|: behaves like `:let &l:{option-name}` for buffer-local options
+- |vim.wo|: behaves like `:let &l:{option-name}` for window-local options
 
     >
-    vim.o.smarttab = false
+    vim.o.smarttab = false -- let &smarttab = v:false
     print(vim.o.smarttab) -- false
-    vim.o.isfname = vim.o.isfname .. ',@-@' -- on Linux: set isfname+=@-@
+    vim.o.isfname = vim.o.isfname .. ',@-@' -- on Linux: let &isfname =
+    &isfname .. ',@-@'
     print(vim.o.isfname) -- '@,48-57,/,.,-,_,+,,,#,$,%,~,=,@-@'
 
     vim.bo.shiftwidth = 4
@@ -1141,43 +1145,162 @@ first argument, with `0` representing the current buffer.
 DEFINING USER COMMANDS
                                                *luaguide-defining-user-commands*
 
-The interface to create user commands was implemented in the PR below
-and is currently available only in neovim 0.7+ (nightly):
+WARNING: The API functions discussed in this section are only available
+in Neovim 0.7.0+
 
--  Pull request #16752: https://github.com/neovim/neovim/pull/16752
+Neovim provides API functions for user-defined commands:
 
-- Global user command:
-  - |nvim_add_user_command()|
-  - |nvim_del_user_command()|
+- Global user commands:
+    - |nvim_create_user_command()|
+    - |nvim_del_user_command()|
 - Buffer-local user commands:
-  - |nvim_buf_add_user_command()|
-  - |nvim_buf_del_user_command()|
+    - |nvim_buf_create_user_command()|
+    - |nvim_buf_del_user_command()|
+
+Let's start with `vim.api.nvim_create_user_command()`
+
+The first argument passed to this function is the name of the command
+(which must start with an uppercase letter).
+
+The second argument is the code to execute when invoking said command. It
+can either be:
+
+A string (in which case it will be executed as Vimscript). You can use
+escape sequences like `<q-args>`, `<range>`, etc. like you would with
+`:command`
+    >
+    vim.api.nvim_create_user_command('Upper', 'echo toupper(<q-args>)',
+    { nargs = 1 })
+    -- :command! -nargs=1 Upper echo toupper(<q-args>)
+
+    vim.cmd('Upper hello world') -- prints "HELLO WORLD"
+<
+
+Or a Lua function. It receives a dictionary-like table that
+contains the data normally provided by escape sequences (see
+|nvim_create_user_command()|
+    >
+    vim.api.nvim_create_user_command(
+        'Upper',
+        function(opts)
+            print(string.upper(opts.args))
+        end,
+        { nargs = 1 }
+    )
+<
+
+The third argument lets you pass command attributes as a table (see
+|command-attributes|`. Since you can already define buffer-local user commands
+with |nvim_buf_create_user_command()|, `-buffer` is not a valid attribute.
+
+Two additional attributes are available:
+- `desc` allows you to control what gets displayed when you run `:command
+{cmd}` on a command defined as a Lua callback.
+- `force` is equivalent to calling `:command!` and replaces a command
+if one with the same name already exists. It is true by default, unlike
+its Vimscript equivalent.
+
+The `-complete` attribute can take a Lua function in addition to the
+attributes listed in |:command-complete|.
+
+    >
+    vim.api.nvim_create_user_command('Upper', function() end, {
+        nargs = 1,
+        complete = function(ArgLead, CmdLine, CursorPos)
+            -- return completion candidates as a list-like table
+            return { 'foo', 'bar', 'baz' }
+        end,
+    })
+<
+
+Buffer-local user commands also take a buffer number as their first
+argument. This is an advantage over `-buffer` which can only define a
+command for the current buffer.
+
+    >
+    vim.api.nvim_buf_create_user_command(4, 'Upper', function() end, {})
+<
+
+`vim.api.nvim_del_user_command()` takes a command name.
+
+    >
+    vim.api.nvim_del_user_command('Upper')
+    -- :delcommand Upper
+<
+
+Again, `vim.api.nvim_buf_del_user_command()`, takes a buffer number as
+its first argument, with `0` representing the current buffer.
+
+    >
+    vim.api.nvim_buf_del_user_command(4, 'Upper')
+<
+
+See also:
+- |nvim_create_user_command()|
+- |40.2|
+- |command-attributes|
+
+Caveats~
+
+The `-complete=custom` attribute automatically filters completion
+candidates and has built-in wildcard (|wildcard| support:
+
+    >
+    function! s:completion_function(ArgLead, CmdLine, CursorPos) abort
+        return join([
+            \ 'strawberry',
+            \ 'star',
+            \ 'stellar',
+            \ ], "\n")
+    endfunction
+
+    command! -nargs=1 -complete=custom,s:completion_function Test echo
+    <q-args>
+    " Typing `:Test st[ae]<Tab>` returns "star" and "stellar"
+<
+
+Passing a Lua function to `complete` makes it behave like `customlist`
+which leaves filtering up to the user:
+
+    >
+    vim.api.nvim_create_user_command('Test', function() end, {
+        nargs = 1,
+        complete = function(ArgLead, CmdLine, CursorPos)
+            return {
+                'strawberry',
+                'star',
+                'stellar',
+            }
+        end,
+    })
+
+    -- Typing `:Test z<Tab>` returns all the completion results because
+    the list was not filtered
+<
 
 ==============================================================================
 DEFINING AUTOCOMMANDS
                                                 *luaguide-defining-autocommands*
 
-Augroups and autocommands do not have an interface yet but it is being
-worked on:
+(this section is a work in progress)
+
+Neovim 0.7.0 has API functions for autocommands. See `:help api-autocmd`
+for details
 
--  Pull request #12378: https://github.com/neovim/neovim/pull/12378
 -  Pull request #14661: https://github.com/neovim/neovim/pull/14661   lua:
 autocmds take 2
 
-In the meantime, you can either create autocommands in
-Vimscript or use  this wrapper from norcalli/nvim_utils:
-https://github.com/norcalli/nvim_utils/blob/master/lua/nvim_utils.lua#L554-L567
-
 ==============================================================================
-DEFINING SYNTAX/HIGHLIGHTS
-                                           *luaguide-defining-syntax-highlights*
+DEFINING HIGHLIGHTS
+                                                  *luaguide-defining-highlights*
 
-The syntax API is still a work in progress. Here are a couple of pointers:
+(this section is a work in progress)
 
--  Issue #9876: https://github.com/neovim/neovim/issues/9876
--  tjdevries/colorbuddy.vim, a library for creating colorschemes in Lua:
-https://github.com/tjdevries/colorbuddy.vim
-- |lua-treesitter|
+Neovim 0.7.0 has API functions for highlight groups. See also:
+
+- |nvim_set_hl()|
+- |nvim_get_hl_by_id()|
+- |nvim_get_hl_by_name()|
 
 ==============================================================================
 GENERAL TIPS AND RECOMMENDATIONS
@@ -1366,6 +1489,32 @@ a debug adapter requires a DAP client like  mfussenegger/nvim-dap:
 https://github.com/mfussenegger/nvim-dap/  or  puremourning/vimspector:
 https://github.com/puremourning/vimspector/ .
 
+Debugging Lua mappings/commands/autocommands~
+
+The `:verbose` command allows you to see where a
+mapping/command/autocommand was defined:
+
+    >
+    :verbose map m
+<
+
+    >
+    n  m_          * <Cmd>echo 'example'<CR>
+            Last set from ~/.config/nvim/init.vim line 26
+<
+
+By default, this feature is disabled in Lua for performance reasons. You
+can enable it by starting Neovim with a verbose level greater than 0:
+
+    >
+    nvim -V1
+<
+
+See also:
+- |'verbose'|
+- |-V|
+-  neovim/neovim#15079: https://github.com/neovim/neovim/pull/15079
+
 Testing Lua code~
 
 -  plenary.nvim: test harness:
@@ -1451,10 +1600,17 @@ Olical/conjure: https://github.com/Olical/conjure  plugin provides an
 interactive development environment that supports Fennel  among other
 languages .
 
+-  Teal: https://github.com/teal-language/tl
+
+The name Teal comes from pronouncing TL  typed lua .  This is exactly
+what it tries to do - add strong typing to lua while otherwise
+remaining close to standard lua syntax.  The  nvim-teal-maker:
+https://github.com/svermeulen/nvim-teal-maker  plugin can be used to
+write Neovim plugins or configuration files directly in Teal
+
 Other interesting projects:
 -  TypeScriptToLua/TypeScriptToLua:
 https://github.com/TypeScriptToLua/TypeScriptToLua
--  teal-language/tl: https://github.com/teal-language/tl
 -  Haxe: https://haxe.org/
 -  SwadicalRag/wasm2lua: https://github.com/SwadicalRag/wasm2lua
 -  hengestone/lua-languages: https://github.com/hengestone/lua-languages