Merge c87d2520c2 into ea7469f1c8

docs/manual/hacking/keybinds.md

@@ -30,12 +30,53 @@ There are many settings available in the options. Please refer to the
 [documentation](https://notashelf.github.io/nvf/options.html#opt-vim.keymaps) to
 see a list of them.
 
-**nvf** provides a helper function, so that you don't have to write the
+**nvf** provides a list of helper commands, so that you don't have to write the
 mapping attribute sets every time:
 
-- `mkKeymap`, which mimics neovim's `vim.keymap.set` function
+- `mkBinding = key: action: desc:` - makes a basic binding, with `silent` set to
+  true.
+- `mkExprBinding = key: action: desc:` - makes an expression binding, with
+  `lua`, `silent`, and `expr` set to true.
+- `mkLuaBinding = key: action: desc:` - makes an expression binding, with `lua`,
+  and `silent` set to true.
 
-You can read the source code of some modules to see them in action, but the
+Do note that the Lua in these bindings is actual Lua, and not pasted into a
+`:lua` command. Therefore, you should either pass in a function like
+`require('someplugin').some_function`, without actually calling it, or you
+should define your own functions, for example
+
+```lua
+function()
+  require('someplugin').some_function()
+end
+```
+
+Additionally, to not have to repeat the descriptions, there's another utility
+function with its own set of functions: Utility function that takes two
+attribute sets:
+
+- `{ someKey = "some_value" }`
+- `{ someKey = { description = "Some Description"; }; }`
+
+and merges them into
+`{ someKey = { value = "some_value"; description = "Some Description"; }; }`
+
+```nix
+addDescriptionsToMappings = actualMappings: mappingDefinitions:
+```
+
+This function can be used in combination with the same `mkBinding` functions as
+above, except they only take two arguments - `binding` and `action`, and have
+different names:
+
+- `mkSetBinding = binding: action:` - makes a basic binding, with `silent` set
+  to true.
+- `mkSetExprBinding = binding: action:` - makes an expression binding, with
+  `lua`, `silent`, and `expr` set to true.
+- `mkSetLuaBinding = binding: action:` - makes an expression binding, with
+  `lua`, and `silent` set to true.
+
+You can read the source code of some modules to see them in action, but their
 usage should look something like this:
 
 ```nix
@@ -49,13 +90,20 @@ in {
 
     # Mappings should always be inside an attrset called mappings
     mappings = {
-      workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";
-      documentDiagnostics = mkMappingOption "Document diagnostics [trouble]" "<leader>ld";
-      lspReferences = mkMappingOption "LSP References [trouble]" "<leader>lr";
-      quickfix = mkMappingOption "QuickFix [trouble]" "<leader>xq";
-      locList = mkMappingOption "LOCList [trouble]" "<leader>xl";
-      symbols = mkMappingOption "Symbols [trouble]" "<leader>xs";
+      # mkMappingOption is a helper function from lib,
+      # that takes a description (which will also appear in which-key),
+      # and a default mapping (which can be null)
+      toggleCurrentLine = mkMappingOption "Toggle current line comment" "gcc";
+      toggleCurrentBlock = mkMappingOption "Toggle current block comment" "gbc";
+
+      toggleOpLeaderLine = mkMappingOption "Toggle line comment" "gc";
+      toggleOpLeaderBlock = mkMappingOption "Toggle block comment" "gb";
+
+      toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
+      toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
     };
+
+  };
 }
 ```
 
@@ -63,27 +111,56 @@ in {
 # config.nix
 {
   config,
+  pkgs,
   lib,
-  options,
   ...
 }: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) mkKeymap;
+    inherit (lib.modules) mkIf mkMerge;
+    inherit (lib.nvim.binds) mkSetBinding;
 
-  cfg = config.vim.plugin;
+    cfg = config.vim.plugin;
+    self = import ./plugindefinition.nix {inherit lib;};
+    mappingDefinitions = self.options.vim.plugin;
 
-  keys = cfg.mappings;
-  inherit (options.vim.lsp.trouble) mappings;
+    # addDescriptionsToMappings is a helper function from lib,
+    # that merges mapping values and their descriptions
+    # into one nice attribute set
+    mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
 in {
-  config = mkIf cfg.enable {
-    vim.keymaps = [
-      (mkKeymap "n" keys.workspaceDiagnostics "<cmd>Trouble toggle diagnostics<CR>" {desc = mappings.workspaceDiagnostics.description;})
-      (mkKeymap "n" keys.documentDiagnostics "<cmd>Trouble toggle diagnostics filter.buf=0<CR>" {desc = mappings.documentDiagnostics.description;})
-      (mkKeymap "n" keys.lspReferences "<cmd>Trouble toggle lsp_references<CR>" {desc = mappings.lspReferences.description;})
-      (mkKeymap "n" keys.quickfix "<cmd>Trouble toggle quickfix<CR>" {desc = mappings.quickfix.description;})
-      (mkKeymap "n" keys.locList "<cmd>Trouble toggle loclist<CR>" {desc = mappings.locList.description;})
-      (mkKeymap "n" keys.symbols "<cmd>Trouble toggle symbols<CR>" {desc = mappings.symbols.description;})
+  config = mkIf (cfg.enable) {
+    # ...
+    vim.maps.normal = mkMerge [
+      # mkSetBinding is another helper function from lib,
+      # that actually adds the mapping with a description.
+      (mkSetBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
+      (mkSetBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
+      (mkSetBinding mappings.buffers "<cmd> Telescope buffers<CR>")
+      (mkSetBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
+      (mkSetBinding mappings.open "<cmd> Telescope<CR>")
+
+      (mkSetBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
+      (mkSetBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
+      (mkSetBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
+      (mkSetBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
+      (mkSetBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+
+      (mkIf config.vim.lsp.enable (mkMerge [
+        (mkSetBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
+        (mkSetBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
+
+        (mkSetBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
+        (mkSetBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
+        (mkSetBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
+        (mkSetBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
+        (mkSetBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
+      ]))
+
+      (
+        mkIf config.vim.treesitter.enable
+        (mkSetBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
+      )
     ];
+    # ...
   };
 }
 ```

docs/release-notes/rl-0.7.md

@@ -160,7 +160,6 @@ The changes are, in no particular order:
 [lz.n]: https://github.com/mrcjkb/lz.n
 
 - Add [lz.n] support and lazy-load some builtin plugins.
-- Add simpler helper functions for making keymaps
 
 [jacekpoz](https://jacekpoz.pl):
 

lib/binds.nix

@@ -68,7 +68,29 @@
 
     pushDownDefault = attr: mapAttrs (_: mkDefault) attr;
 
-    mkKeymap = mode: key: action: opt: opt // {inherit mode key action;};
+    mkLznBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+    };
+
+    mkLznExprBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+      lua = true;
+      silent = true;
+      expr = true;
+    };
+
+    mkSetLznBinding = mode: binding: action: {
+      inherit action mode;
+      key = binding.value;
+      desc = binding.description;
+    };
+
+    mkSetLuaLznBinding = mode: binding: action: {
+      inherit action mode;
+      key = binding.value;
+      lua = true;
+      desc = binding.description;
+    };
   };
 in
   binds

modules/plugins/comments/comment-nvim/config.nix

@@ -1,14 +1,14 @@
 {
-  options,
   config,
   lib,
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) mkKeymap;
+  inherit (lib.nvim.binds) mkLznExprBinding mkLznBinding;
 
   cfg = config.vim.comments.comment-nvim;
-  inherit (options.vim.comments.comment-nvim) mappings;
+  self = import ./comment-nvim.nix {inherit lib;};
+  inherit (self.options.vim.comments.comment-nvim) mappings;
 in {
   config = mkIf cfg.enable {
     vim.lazy.plugins.comment-nvim = {
@@ -16,28 +16,24 @@ in {
       setupModule = "Comment";
       inherit (cfg) setupOpts;
       keys = [
-        (mkKeymap "n" cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" {desc = mappings.toggleOpLeaderLine.description;})
-        (mkKeymap "n" cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" {desc = mappings.toggleOpLeaderBlock.description;})
-        (mkKeymap "n" cfg.mappings.toggleCurrentLine ''
+        (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+        (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+        (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
             function()
               return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
                       or '<Plug>(comment_toggle_linewise_count)'
             end
-          '' {
-            expr = true;
-            desc = mappings.toggleCurrentLine.description;
-          })
-        (mkKeymap ["n"] cfg.mappings.toggleCurrentBlock ''
+          ''
+          mappings.toggleCurrentLine.description)
+        (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
             function()
               return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
                       or '<Plug>(comment_toggle_blockwise_count)'
             end
-          '' {
-            expr = true;
-            desc = mappings.toggleCurrentBlock.description;
-          })
-        (mkKeymap "x" cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" {desc = mappings.toggleSelectedLine.description;})
-        (mkKeymap "x" cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" {desc = mappings.toggleSelectedBlock.description;})
+          ''
+          mappings.toggleCurrentBlock.description)
+        (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+        (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
       ];
     };
   };

modules/plugins/debugger/nvim-dap/config.nix

@@ -1,5 +1,4 @@
 {
-  options,
   config,
   lib,
   ...
@@ -7,11 +6,13 @@
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.attrsets) mapAttrs;
-  inherit (lib.nvim.binds) mkKeymap;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding mkSetLuaLznBinding;
   inherit (lib.nvim.dag) entryAnywhere entryAfter;
 
   cfg = config.vim.debugger.nvim-dap;
-  inherit (options.vim.debugger.nvim-dap) mappings;
+  self = import ./nvim-dap.nix {inherit lib;};
+  mappingDefinitions = self.options.vim.debugger.nvim-dap.mappings;
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
 in {
   config = mkMerge [
     (mkIf cfg.enable {
@@ -28,24 +29,24 @@ in {
           }
           // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
 
-        keymaps = [
-          (mkKeymap "n" cfg.mappings.continue "require('dap').continue" {desc = mappings.continue.description;})
-          (mkKeymap "n" cfg.mappings.restart "require('dap').restart" {desc = mappings.restart.description;})
-          (mkKeymap "n" cfg.mappings.terminate "require('dap').terminate" {desc = mappings.terminate.description;})
-          (mkKeymap "n" cfg.mappings.runLast "require('dap').run_last" {desc = mappings.runLast.description;})
+        maps.normal = mkMerge [
+          (mkSetLuaBinding mappings.continue "require('dap').continue")
+          (mkSetLuaBinding mappings.restart "require('dap').restart")
+          (mkSetLuaBinding mappings.terminate "require('dap').terminate")
+          (mkSetLuaBinding mappings.runLast "require('dap').run_last")
 
-          (mkKeymap "n" cfg.mappings.toggleRepl "require('dap').repl.toggle" {desc = mappings.toggleRepl.description;})
-          (mkKeymap "n" cfg.mappings.hover "require('dap.ui.widgets').hover" {desc = mappings.hover.description;})
-          (mkKeymap "n" cfg.mappings.toggleBreakpoint "require('dap').toggle_breakpoint" {desc = mappings.toggleBreakpoint.description;})
+          (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
+          (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
+          (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
 
-          (mkKeymap "n" cfg.mappings.runToCursor "require('dap').run_to_cursor" {desc = mappings.runToCursor.description;})
-          (mkKeymap "n" cfg.mappings.stepInto "require('dap').step_into" {desc = mappings.stepInto.description;})
-          (mkKeymap "n" cfg.mappings.stepOut "require('dap').step_out" {desc = mappings.stepOut.description;})
-          (mkKeymap "n" cfg.mappings.stepOver "require('dap').step_over" {desc = mappings.stepOver.description;})
-          (mkKeymap "n" cfg.mappings.stepBack "require('dap').step_back" {desc = mappings.stepBack.description;})
+          (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
+          (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
+          (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
+          (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
+          (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
 
-          (mkKeymap "n" cfg.mappings.goUp "require('dap').up" {desc = mappings.goUp.description;})
-          (mkKeymap "n" cfg.mappings.goDown "require('dap').down" {desc = mappings.goDown.description;})
+          (mkSetLuaBinding mappings.goUp "require('dap').up")
+          (mkSetLuaBinding mappings.goDown "require('dap').down")
         ];
       };
     })
@@ -59,7 +60,7 @@ in {
           inherit (cfg.ui) setupOpts;
 
           keys = [
-            (mkKeymap "n" cfg.mappings.toggleDapUI "function() require('dapui').toggle() end" {desc = mappings.toggleDapUI.description;})
+            (mkSetLuaLznBinding "n" mappings.toggleDapUI "function() require('dapui').toggle() end")
           ];
         };
 

modules/plugins/filetree/nvimtree/config.nix

@@ -6,7 +6,7 @@
 }: let
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) mkKeymap;
+  inherit (lib.nvim.binds) mkLznBinding;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.binds) pushDownDefault;
 
@@ -27,10 +27,10 @@ in {
 
         cmd = ["NvimTreeClipboard" "NvimTreeClose" "NvimTreeCollapse" "NvimTreeCollapseKeepBuffers" "NvimTreeFindFile" "NvimTreeFindFileToggle" "NvimTreeFocus" "NvimTreeHiTest" "NvimTreeOpen" "NvimTreeRefresh" "NvimTreeResize" "NvimTreeToggle"];
         keys = [
-          (mkKeymap "n" cfg.mappings.toggle ":NvimTreeToggle<cr>" {desc = mappings.toggle.description;})
-          (mkKeymap "n" cfg.mappings.refresh ":NvimTreeRefresh<cr>" {desc = mappings.refresh.description;})
-          (mkKeymap "n" cfg.mappings.findFile ":NvimTreeFindFile<cr>" {desc = mappings.findFile.description;})
-          (mkKeymap "n" cfg.mappings.focus ":NvimTreeFocus<cr>" {desc = mappings.focus.description;})
+          (mkLznBinding ["n"] cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
+          (mkLznBinding ["n"] cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
+          (mkLznBinding ["n"] cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
+          (mkLznBinding ["n"] cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
         ];
       };
 

modules/plugins/lsp/trouble/config.nix

@@ -5,11 +5,12 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.binds) mkKeymap pushDownDefault;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLznBinding pushDownDefault;
 
   cfg = config.vim.lsp;
 
-  inherit (options.vim.lsp.trouble) mappings;
+  mappingDefinitions = options.vim.lsp.trouble.mappings;
+  mappings = addDescriptionsToMappings cfg.trouble.mappings mappingDefinitions;
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {
     vim = {
@@ -20,12 +21,12 @@ in {
 
         cmd = "Trouble";
         keys = [
-          (mkKeymap "n" cfg.trouble.mappings.workspaceDiagnostics "<cmd>Trouble toggle diagnostics<CR>" {desc = mappings.workspaceDiagnostics.description;})
-          (mkKeymap "n" cfg.trouble.mappings.documentDiagnostics "<cmd>Trouble toggle diagnostics filter.buf=0<CR>" {desc = mappings.documentDiagnostics.description;})
-          (mkKeymap "n" cfg.trouble.mappings.lspReferences "<cmd>Trouble toggle lsp_references<CR>" {desc = mappings.lspReferences.description;})
-          (mkKeymap "n" cfg.trouble.mappings.quickfix "<cmd>Trouble toggle quickfix<CR>" {desc = mappings.quickfix.description;})
-          (mkKeymap "n" cfg.trouble.mappings.locList "<cmd>Trouble toggle loclist<CR>" {desc = mappings.locList.description;})
-          (mkKeymap "n" cfg.trouble.mappings.symbols "<cmd>Trouble toggle symbols<CR>" {desc = mappings.symbols.description;})
+          (mkSetLznBinding "n" mappings.workspaceDiagnostics "<cmd>Trouble toggle diagnostics<CR>")
+          (mkSetLznBinding "n" mappings.documentDiagnostics "<cmd>Trouble toggle diagnostics filter.buf=0<CR>")
+          (mkSetLznBinding "n" mappings.lspReferences "<cmd>Trouble toggle lsp_references<CR>")
+          (mkSetLznBinding "n" mappings.quickfix "<cmd>Trouble toggle quickfix<CR>")
+          (mkSetLznBinding "n" mappings.locList "<cmd>Trouble toggle loclist<CR>")
+          (mkSetLznBinding "n" mappings.symbols "<cmd>Trouble toggle symbols<CR>")
         ];
       };
 

modules/plugins/terminal/toggleterm/config.nix

@@ -7,7 +7,7 @@
   inherit (lib.lists) optional;
   inherit (lib.modules) mkIf;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.binds) mkKeymap;
+  inherit (lib.nvim.binds) mkLznBinding;
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.terminal.toggleterm;
@@ -19,7 +19,7 @@ in {
         package = "toggleterm-nvim";
         cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
         keys =
-          [(mkKeymap "n" cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" {desc = "Toggle terminal";})]
+          [(mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")]
           ++ optional cfg.lazygit.enable {
             key = cfg.lazygit.mappings.open;
             mode = "n";

modules/plugins/utility/motion/leap/config.nix

@@ -4,7 +4,7 @@
   ...
 }: let
   inherit (lib.modules) mkIf mkDefault;
-  inherit (lib.nvim.binds) mkKeymap;
+  inherit (lib.nvim.binds) mkLznBinding;
 
   cfg = config.vim.utility.motion.leap;
 in {
@@ -14,11 +14,11 @@ in {
       lazy.plugins.leap-nvim = {
         package = "leap-nvim";
         keys = [
-          (mkKeymap ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" {desc = "Leap forward to";})
-          (mkKeymap ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" {desc = "Leap backward to";})
-          (mkKeymap ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" {desc = "Leap forward till";})
-          (mkKeymap ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" {desc = "Leap backward till";})
-          (mkKeymap ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" {desc = "Leap from window";})
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
+          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
         ];
 
         after = ''

modules/plugins/utility/telescope/config.nix

@@ -5,14 +5,15 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) addDescriptionsToMappings;
   inherit (lib.strings) optionalString;
   inherit (lib.lists) optionals;
-  inherit (lib.nvim.binds) pushDownDefault mkKeymap;
+  inherit (lib.nvim.binds) pushDownDefault mkSetLznBinding;
 
   cfg = config.vim.telescope;
+  mappingDefinitions = options.vim.telescope.mappings;
 
-  keys = cfg.mappings;
-  inherit (options.vim.telescope) mappings;
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
 in {
   config = mkIf cfg.enable {
     vim = {
@@ -33,35 +34,39 @@ in {
 
         keys =
           [
-            (mkKeymap "n" keys.findFiles "<cmd>Telescope find_files<CR>" {desc = mappings.findFiles.description;})
-            (mkKeymap "n" keys.liveGrep "<cmd>Telescope live_grep<CR>" {desc = mappings.liveGrep.description;})
-            (mkKeymap "n" keys.buffers "<cmd>Telescope buffers<CR>" {desc = mappings.buffers.description;})
-            (mkKeymap "n" keys.helpTags "<cmd>Telescope help_tags<CR>" {desc = mappings.helpTags.description;})
-            (mkKeymap "n" keys.open "<cmd>Telescope<CR>" {desc = mappings.open.description;})
-            (mkKeymap "n" keys.resume "<cmd>Telescope resume<CR>" {desc = mappings.resume.description;})
+            (mkSetLznBinding "n" mappings.findFiles "<cmd>Telescope find_files<CR>")
+            (mkSetLznBinding "n" mappings.liveGrep "<cmd>Telescope live_grep<CR>")
+            (mkSetLznBinding "n" mappings.buffers "<cmd>Telescope buffers<CR>")
+            (mkSetLznBinding "n" mappings.helpTags "<cmd>Telescope help_tags<CR>")
+            (mkSetLznBinding "n" mappings.open "<cmd>Telescope<CR>")
+            (mkSetLznBinding "n" mappings.resume "<cmd>Telescope resume<CR>")
 
-            (mkKeymap "n" keys.gitCommits "<cmd>Telescope git_commits<CR>" {desc = mappings.gitCommits.description;})
-            (mkKeymap "n" keys.gitBufferCommits "<cmd>Telescope git_bcommits<CR>" {desc = mappings.gitBufferCommits.description;})
-            (mkKeymap "n" keys.gitBranches "<cmd>Telescope git_branches<CR>" {desc = mappings.gitBranches.description;})
-            (mkKeymap "n" keys.gitStatus "<cmd>Telescope git_status<CR>" {desc = mappings.gitStatus.description;})
-            (mkKeymap "n" keys.gitStash "<cmd>Telescope git_stash<CR>" {desc = mappings.gitStash.description;})
+            (mkSetLznBinding "n" mappings.gitCommits "<cmd>Telescope git_commits<CR>")
+            (mkSetLznBinding "n" mappings.gitBufferCommits "<cmd>Telescope git_bcommits<CR>")
+            (mkSetLznBinding "n" mappings.gitBranches "<cmd>Telescope git_branches<CR>")
+            (mkSetLznBinding "n" mappings.gitStatus "<cmd>Telescope git_status<CR>")
+            (mkSetLznBinding "n" mappings.gitStash "<cmd>Telescope git_stash<CR>")
           ]
           ++ (optionals config.vim.lsp.enable [
-            (mkKeymap "n" keys.lspDocumentSymbols "<cmd>Telescope lsp_document_symbols<CR>" {desc = mappings.lspDocumentSymbols.description;})
-            (mkKeymap "n" keys.lspWorkspaceSymbols "<cmd>Telescope lsp_workspace_symbols<CR>" {desc = mappings.lspWorkspaceSymbols.description;})
+            (mkSetLznBinding "n" mappings.lspDocumentSymbols "<cmd>Telescope lsp_document_symbols<CR>")
+            (mkSetLznBinding "n" mappings.lspWorkspaceSymbols "<cmd>Telescope lsp_workspace_symbols<CR>")
 
-            (mkKeymap "n" keys.lspReferences "<cmd>Telescope lsp_references<CR>" {desc = mappings.lspReferences.description;})
-            (mkKeymap "n" keys.lspImplementations "<cmd>Telescope lsp_implementations<CR>" {desc = mappings.lspImplementations.description;})
-            (mkKeymap "n" keys.lspDefinitions "<cmd>Telescope lsp_definitions<CR>" {desc = mappings.lspDefinitions.description;})
-            (mkKeymap "n" keys.lspTypeDefinitions "<cmd>Telescope lsp_type_definitions<CR>" {desc = mappings.lspTypeDefinitions.description;})
-            (mkKeymap "n" keys.diagnostics "<cmd>Telescope diagnostics<CR>" {desc = mappings.diagnostics.description;})
+            (mkSetLznBinding "n" mappings.lspReferences "<cmd>Telescope lsp_references<CR>")
+            (mkSetLznBinding "n" mappings.lspImplementations "<cmd>Telescope lsp_implementations<CR>")
+            (mkSetLznBinding "n" mappings.lspDefinitions "<cmd>Telescope lsp_definitions<CR>")
+            (mkSetLznBinding "n" mappings.lspTypeDefinitions "<cmd>Telescope lsp_type_definitions<CR>")
+            (mkSetLznBinding "n" mappings.diagnostics "<cmd>Telescope diagnostics<CR>")
           ])
-          ++ optionals config.vim.treesitter.enable [
-            (mkKeymap "n" keys.treesitter "<cmd>Telescope treesitter<CR>" {desc = mappings.treesitter.description;})
-          ]
-          ++ optionals config.vim.projects.project-nvim.enable [
-            (mkKeymap "n" keys.findProjects "<cmd>Telescope projects<CR>" {desc = mappings.findProjects.description;})
-          ];
+          ++ (
+            optionals config.vim.treesitter.enable [
+              (mkSetLznBinding "n" mappings.treesitter "<cmd>Telescope treesitter<CR>")
+            ]
+          )
+          ++ (
+            optionals config.vim.projects.project-nvim.enable [
+              (mkSetLznBinding "n" mappings.findProjects "<cmd>Telescope projects<CR>")
+            ]
+          );
       };
 
       binds.whichKey.register = pushDownDefault {