diff --git a/modules/vim/options.nix b/modules/vim/options.nix
index 3f6a2df..7e05ad5 100644
--- a/modules/vim/options.nix
+++ b/modules/vim/options.nix
@@ -1,9 +1,30 @@
 { lib }:
 
 let
+  inherit (builtins) mapAttrs;
+  mkVimOptOption =
+    key:
+    { type
+    , default
+    , description ? ""
+    , extraHelp ? [ ]
+    , apply ? null
+    }:
+    lib.mkOption {
+      type = lib.types.nullOr type;
+      inherit apply;
+      default = null;
+      defaultText = lib.literalExpression (builtins.toJSON default);
+      description = lib.concatLines (
+        [ description "" ]
+        ++ map (help: "`:help ${help}") ([ key ] ++ extraHelp)
+      );
+    };
+
+
   sharedGlobalOrWindow = with lib; with types; {
-    fillchars = mkOption {
-      type = nullOr (listOf (enum [
+    fillchars = {
+      type = (listOf (enum [
         "stl"
         "stlnc"
         "wbr"
@@ -23,147 +44,116 @@ let
         "eob"
         "lastline"
       ]));
-      default = null;
-      defaultText = literalExpression "[]";
+      default = [ ];
       description = ''
         Characters to fill the statuslines, vertical separators and special lines in the window.
-
-        `:help fillchars`
       '';
     };
   };
 
   sharedGlobalOrBuffer = with lib; with types; {
-    autoread = mkOption {
-      type = nullOr bool;
-      default = null;
+    autoread = {
+      type = bool;
       description = ''
         When a file has been detected to have been changed outside of Vim and
         it has not been changed inside of Vim, automatically read it again.
         When the file has been deleted this is not done, so you have the text
         from before it was deleted.  When it appears again then it is read.
         |timestamp|
-
-        `:help autoread`
       '';
     };
 
-    backupcopy = mkOption {
-      type = nullOr (listOf (enum [ "yes" "no" "auto" "breaksymlink" "breakhardlink" ]));
-      default = null;
+    backupcopy = {
+      type = (listOf (enum [ "yes" "no" "auto" "breaksymlink" "breakhardlink" ]));
       description = ''
         When writing a file and a backup is made, this option tells how it's
         done.  This is a comma-separated list of words.
-
-        `:help backupcopy`
       '';
     };
 
-    formatprg = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    formatprg = {
+      type = str;
+      default = "";
       description = ''
         The name of an external program that will be used to format the lines
         selected with the |gq| operator.  The program must take the input on
         stdin and produce the output on stdout.
-
-        `:help formatprg`
       '';
     };
 
-    grepprg = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = literalExpression ''
+    grepprg = {
+      type = str;
+      default = ''
         default "grep -n ",
         Unix: "grep -n $* /dev/null"
-
-        `:help grepprg`
       '';
     };
 
-    include = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = ''^\s*#\s*include'';
+    include = {
+      type = str;
+      default = ''^\s*#\s*include'';
       description = ''
         Pattern to be used to find an include command.
-
-        `:help include`
       '';
     };
 
-    keywordprg = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = literalExpression ''
+    keywordprg = {
+      type = str;
+      default = ''
         Windows: ":help"
         otherwise: ":Man"
       '';
       description = ''
         Program to use for the |K| command.
-
-        `:help keywordprg`
       '';
     };
 
-    lispwords = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "is very long";
+    lispwords = {
+      type = (listOf str);
+      default = is very long;
       description = ''
         list of words that influence the Lisp indenting when
         enabled with the |'lisp'| option.
-
-        `:help lispwords`
       '';
     };
 
-    makeencoding = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    makeencoding = {
+      type = str;
+      default = "";
       description = ''
         Encoding used for reading the output of external commands.  When empty,
         encoding is not converted.
         This is used for `:make`, `:lmake`, `:grep`, `:lgrep`, `:grepadd`,
         `:lgrepadd`, `:cfile`, `:cgetfile`, `:caddfile`, `:lfile`, `:lgetfile`,
         and `:laddfile`.
-
-        `:help makeencoding`
+ 
       '';
     };
   };
 
   global = with lib; with types; sharedGlobalOrWindow // sharedGlobalOrBuffer // {
-    allowrevins = mkOption {
-      type = nullOr bool;
-      default = null;
+    allowrevins = {
+      type = bool;
       description = ''
         Allow CTRL-_ in Insert and Command-line mode.  This is default off, to
         avoid that users that accidentally type CTRL-_ instead of SHIFT-_ get
         into reverse Insert mode, and don't know how to get out.  See
-
-        `:help allowrevins`
+ 
       '';
     };
 
-    ambiwidth = mkOption {
-      type = nullOr (enum [ "single" "double" ]);
-      default = null;
+    ambiwidth = {
+      type = (enum [ "single" "double" ]);
       description = ''
         Tells Vim what to do with characters with East Asian Width Class
         Ambiguous (such as Euro, Registered Sign, Copyright Sign, Greek
         letters, Cyrillic letters).
-
-        `:help ambiwidth`
+ 
       '';
     };
 
-    autochdir = mkOption {
-      type = nullOr bool;
-      default = null;
+    autochdir = {
+      type = bool;
       description = ''
         When on, Vim will change the current working directory whenever you
         open a file, switch buffers, delete a buffer or open/close a window.
@@ -171,54 +161,45 @@ let
         or selected.  When a buffer has no name it also has no directory, thus
         the current directory won't change when navigating to it.
         Note: When this option is on some plugins may not work.
-
-        `:help autochdir`
+ 
       '';
     };
 
-    arabicshape = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    arabicshape = {
+      type = bool;
+      default = false;
       description = ''
         When on and 'termbidi' is off, the required visual character
         corrections that need to take place for displaying the Arabic language
         take effect.
-
-        `:help arabicshape`
+ 
       '';
     };
 
-    autowrite = mkOption {
-      type = nullOr bool;
-      default = null;
+    autowrite = {
+      type = bool;
       description = ''
         Write the contents of the file, if it has been modified, on each
         `:next`, `:rewind`, `:last`, `:first`, `:previous`, `:stop`,
         `:suspend`, `:tag`, `:!`, `:make`, CTRL-] and CTRL-^ command; and when
         a `:buffer`, CTRL-O, CTRL-I, '{A-Z0-9}, or `{A-Z0-9} command takes one
         to another file.
-
-        `:help autowrite`
+ 
       '';
     };
 
-    autowriteall = mkOption {
-      type = nullOr bool;
-      default = null;
+    autowriteall = {
+      type = bool;
       description = ''
         	Like 'autowrite', but also used for commands ":edit", ":enew", ":quit",
         	":qall", ":exit", ":xit", ":recover" and closing the Vim window.
         	Setting this option also implies that Vim behaves like 'autowrite' has
-        	been set.
-        
-          `:help autowriteall`
+        	been set. 
       '';
     };
 
-    background = mkOption {
-      type = nullOr string;
-      default = null;
+    background = {
+      type = str;
       description = ''
         When set to "dark" or "light", adjusts the default color groups for
         that background type.  The |TUI| or other UI sets this on startup
@@ -233,26 +214,22 @@ let
         the color scheme adjusts to the value of 'background' this will work.
         However, if the color scheme sets 'background' itself the effect may
         be undone.  First delete the "g:colors_name" variable when needed.
-
-        `:help background`
+ 
       '';
     };
 
-    backspace = mkOption {
-      type = nullOr (listOf (enum [ "indent" "eol" "start" "nostop" ]));
-      default = null;
+    backspace = {
+      type = (listOf (enum [ "indent" "eol" "start" "nostop" ]));
       description = ''
         Influences the working of <BS>, <Del>, CTRL-W and CTRL-U in Insert
         mode.  This is a list of items, separated by commas.  Each item allows
         a way to backspace over something:
-
-        `:help backspace`
+ 
       '';
     };
 
-    backup = mkOption {
-      type = nullOr bool;
-      default = null;
+    backup = {
+      type = bool;
       description = ''
         Make a backup before overwriting a file.  Leave it around after the
         file has been successfully written.  If you do not want to keep the
@@ -261,40 +238,33 @@ let
         the default).  If you do not want a backup file at all reset both
         options (use this if your file system is almost full).  See the
         |backup-table| for more explanations.
-
-        `:help backup`
-        `:help backup-table`
       '';
+      extraHelp = [ "backup-table" ];
     };
 
-    backupdir = mkOption {
-      type = nullOr (listOf (either string path));
-      default = null;
+    backupdir = {
+      type = (listOf (either str path));
       description = ''
         List of directories for the backup file, separated with commas.
-
-        `:help backupdir`
+ 
       '';
     };
 
-    backupext = mkOption {
-      type = nullOr string;
-      default = null;
+    backupext = {
+      type = str;
       description = ''
-        String which is appended to a file name to make the name of the
+        str which is appended to a file name to make the name of the
         backup file.  The default is quite unusual, because this avoids
         accidentally overwriting existing files with a backup file.  You might
         prefer using ".bak", but make sure that you don't have files with
         ".bak" that you want to keep.
         Only normal file name characters can be used; "/\*?[|<>" are illegal.
-
-        `:help backupext`
+ 
       '';
     };
 
-    backupskip = mkOption {
-      type = nullOr (listOf (either string path));
-      default = null;
+    backupskip = {
+      type = (listOf (either str path));
       description = ''
         A list of file patterns.  When one of the patterns matches with the
         name of the file which is written, no backup file is created.  Both
@@ -303,13 +273,12 @@ let
         Watch out for special characters, see |option-backslash|.
         When $TMPDIR, $TMP or $TEMP is not defined, it is not used for the
         default value.  "/tmp/*" is only used for Unix.
-
-        `:help backupskip`
+ 
       '';
     };
 
-    belloff = mkOption {
-      type = nullOr (listOf (enum [
+    belloff = {
+      type = (listOf (enum [
         "all"
         "backspace"
         "cursor"
@@ -328,7 +297,6 @@ let
         "spell"
         "willmode"
       ]));
-      default = null;
       description = ''
         Specifies for which events the bell will not be rung. It is a comma-
         separated list of items. For each item that is present, the bell
@@ -359,39 +327,33 @@ let
         spell	    | Error happened on spell suggest.
         wildmode  | More matches in |cmdline-completion| available
                   | (depends on the 'wildmode' setting).
-
-        `:help belloff`
+ 
       '';
     };
 
-    breakat = mkOption {
-      type = nullOr string;
-      default = null;
+    breakat = {
+      type = str;
       description = ''
         This option lets you choose which characters might cause a line
         break if 'linebreak' is on.  Only works for ASCII characters.
-
-        `:help breakat`
+ 
       '';
     };
 
-    browsedir = mkOption {
-      type = nullOr (either path (enum [ "last" "buffer" "current" ]));
-      default = null;
+    browsedir = {
+      type = (either path (enum [ "last" "buffer" "current" ]));
       description = ''
         Which directory to use for the file browser:
         last		Use same directory as with last file browser, where a file was opened or saved.
         buffer	Use the directory of the related buffer.
         current	Use the current directory.
         {path}	Use the specified directory
-
-        `:help browsedir`
+ 
       '';
     };
 
-    casemap = mkOption {
-      type = nullOr (listOf (enum [ "internal" "keepascii" ]));
-      default = null;
+    casemap = {
+      type = (listOf (enum [ "internal" "keepascii" ]));
       description = ''
         Specifies details about changing the case of letters.  It may contain
         these words, separated by a comma:
@@ -400,68 +362,56 @@ let
           used when available.
         - keepascii - For the ASCII characters (0x00 to 0x7f) use the US case mapping, the current locale
           is not effective. This probably only matters for Turkish.
-
-        `:help casemap`
+ 
       '';
     };
 
-    cedit = mkOption {
-      type = nullOr string;
-      default = null;
+    cedit = {
+      type = str;
       description = ''
         The key used in Command-line Mode to open the command-line window.
         Only non-printable keys are allowed.
-
-        `:help cedit`
+ 
       '';
     };
 
-    charconvert = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    charconvert = {
+      type = str;
+      default = "";
       description = ''
         An expression that is used for character encoding conversion.  It is
         evaluated when a file that is to be read or has been written has a
         different encoding from what is desired.
-
-        `:help charconvert`
+ 
       '';
     };
 
-    clipboard = mkOption {
-      type = nullOr (listOf (enum [ "unnamed" "unnamedplus" ]));
-      default = null;
+    clipboard = {
+      type = (listOf (enum [ "unnamed" "unnamedplus" ]));
       description = ''
         This option is a list of comma-separated names.
-
-        `:help clipboard`
+ 
       '';
     };
 
-    cmdheight = mkOption {
-      type = nullOr number;
-      default = null;
+    cmdheight = {
+      type = number;
       description = ''
         Number of screen lines to use for the command-line.  Helps avoiding |hit-enter| prompts.
-
-        `:help cmdheight`
+ 
       '';
     };
 
-    cmdwinheight = mkOption {
-      type = nullOr number;
-      default = null;
+    cmdwinheight = {
+      type = number;
       description = ''
         Number of screen lines to use for the command-line window. 
-
-        `:help cmdwinheight`
-        `:help cmdwin`
       '';
+      extraHelp = [ "cmdwin" ];
     };
 
-    completeopt = mkOption {
-      type = nullOr (listOf (enum [
+    completeopt = {
+      type = (listOf (enum [
         "menu"
         "menuone"
         "longest"
@@ -469,17 +419,14 @@ let
         "noinsert"
         "noselect"
       ]));
-      default = null;
       description = ''
         A comma-separated list of options for Insert mode completion |ins-completion|.
-
-        `:help completeopt`
+ 
       '';
     };
 
-    confirm = mkOption {
-      type = nullOr bool;
-      default = null;
+    confirm = {
+      type = bool;
       description = ''
         When 'confirm' is on, certain operations that would normally
         fail because of unsaved changes to a buffer, e.g. ":q" and ":e",
@@ -488,13 +435,12 @@ let
         If 'confirm' is off you can still activate confirmation for one
         command only (this is most useful in mappings) with the |:confirm|
         command.
-
-        `:help confirm`
+ 
       '';
     };
 
-    cpoptions = mkOption {
-      type = nullOr string;
+    cpoptions = {
+      type = str;
       default = true;
       description = ''
         A sequence of single character flags.  When a character is present
@@ -502,14 +448,12 @@ let
         not being Vi-compatible is mostly or sometimes preferred.
         'cpoptions' stands for "compatible-options".
         Commas can be added for readability.
-
-        `:help cpoptions`
+ 
       '';
     };
 
-    debug = mkOption {
-      type = nullOr (listOf (enum [ "msg" "throw" "beep" ]));
-      default = null;
+    debug = {
+      type = (listOf (enum [ "msg" "throw" "beep" ]));
       description = ''
         These values can be used:
         - msg	Error messages that would otherwise be omitted will be given anyway.
@@ -519,226 +463,188 @@ let
         The values can be combined, separated by a comma.
         "msg" and "throw" are useful for debugging 'foldexpr', 'formatexpr' or
         'indentexpr'.
-
-        `:help debug`
+ 
       '';
     };
 
-    define = mkOption {
-      type = nullOr string;
-      default = null;
+    define = {
+      type = str;
       description = ''
         Pattern to be used to find a macro definition.
-
-        `:help defined`
+ 
       '';
     };
 
-    delcombine = mkOption {
-      type = nullOr bool;
-      default = null;
+    delcombine = {
+      type = bool;
       description = ''
         If editing Unicode and this option is set, backspace and Normal mode
         "x" delete each combining character on its own.  When it is off (the
         default) the character along with its combining characters are
         deleted.
-
-        `:help delcombine`
+ 
       '';
     };
 
-    dictionary = mkOption {
-      type = nullOr (listOf (either string path));
-      default = null;
+    dictionary = {
+      type = (listOf (either str path));
       description = ''
         List of file names, separated by commas, that are used to lookup words
         for keyword completion commands |i_CTRL-X_CTRL-K|.  Each file should
         contain a list of words.  This can be one word per line, or several
         words per line, separated by non-keyword characters (white space is
         preferred).  Maximum line length is 510 bytes.
-
-        `:help dictionary`
+ 
       '';
     };
 
-    diffexpr = mkOption {
-      type = nullOr string;
-      default = null;
+    diffexpr = {
+      type = str;
       description = ''
         Expression which is evaluated to obtain a diff file (either ed-style
         or unified-style) from two versions of a file.
-
-        `:help diffexpr`
-        `:help diff-diffexpr`
+ 
       '';
+      extraHelp = [ "diff-diffexpr" ];
     };
 
-    diffopt = mkOption {
-      type = nullOr (listOf string);
-      default = null;
+    diffopt = {
+      type = (listOf str);
       description = ''
         Option settings for diff mode.
-
-        `:help diffopt`
+ 
       '';
     };
 
-    digraph = mkOption {
-      type = nullOr bool;
-      default = null;
+    digraph = {
+      type = bool;
       description = ''
         Enable the entering of digraphs in Insert mode with {char1} <BS> {char2}.
-
-        `:help digraph`
-        `:help digraphs`
+ 
       '';
+      extraHelp = [ "digraphs" ];
     };
 
-    directory = mkOption {
-      type = nullOr (listOf (either string path));
-      default = null;
+    directory = {
+      type = (listOf (either str path));
       description = ''
         List of directory names for the swap file, separated with commas.
-
-        `:help directory`
+ 
       '';
     };
 
-    display = mkOption {
-      type = nullOr (listOf (enum [ "lastline" "truncate" "uhex" "msgsep" ]));
-      default = null;
+    display = {
+      type = (listOf (enum [ "lastline" "truncate" "uhex" "msgsep" ]));
       description = ''
         Change the way text is displayed.
-
-        `:help display`
+ 
       '';
     };
 
-    eadirection = mkOption {
-      type = nullOr (enum [ "ver" "hor" "both" ]);
-      default = null;
+    eadirection = {
+      type = (enum [ "ver" "hor" "both" ]);
       description = ''
         Tells when the 'equalalways' option applies:
-
-        `:help eadirection`;
+ 
       '';
     };
 
-    emoji = mkOption {
-      type = nullOr bool;
-      default = null;
+    emoji = {
+      type = bool;
       description = ''
         When on all Unicode emoji characters are considered to be full width.
         This excludes "text emoji" characters, which are normally displayed as
         single width.
-
-        `:help emoji`
+ 
       '';
     };
 
-    equalalways = mkOption {
-      type = nullOr bool;
-      default = null;
+    equalalways = {
+      type = bool;
       description = ''
         When on, all the windows are automatically made the same size after
         splitting or closing a window.  This also happens the moment the
         option is switched on.  When off, splitting a window will reduce the
         size of the current window and leave the other windows the same.
-
-        `:help equalalways`
+ 
       '';
     };
 
-    equalprg = mkOption {
-      type = nullOr string;
-      default = null;
+    equalprg = {
+      type = str;
       description = ''
         External program to use for "=" command.  When this option is empty
         the internal formatting functions are used; either 'lisp', 'cindent'
         or 'indentexpr'.
-
-        `:help equalprg`
+ 
       '';
     };
 
-    errorbells = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    errorbells = {
+      type = bool;
+      default = false;
       description = ''
         Ring the bell (beep or screen flash) for error messages.  This only
         makes a difference for error messages, the bell will be used always
         for a lot of errors without a message
-
-        `:help errorbells`
+ 
       '';
     };
 
-    errorfile = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "errors.err";
+    errorfile = {
+      type = str;
+      default = "errors.err";
       description = ''
         Name of the errorfile for the QuickFix mode.
-
-        `:help errorfile`
-        `:help cf`
+ 
       '';
+      extraHelp = [ "cf" ];
     };
 
-    errorformat = mkOption {
-      type = nullOr string;
-      default = null;
+    errorformat = {
+      type = str;
       description = ''
         Scanf-like description of the format for the lines in the error file
-
-        `:help errorformat`
+ 
       '';
     };
 
-    eventignore = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "[]";
+    eventignore = {
+      type = (listOf str);
+      default = [ ];
       description = ''
         A list of autocommand event names, which are to be ignored.
         When set to "all" or when "all" is one of the items, all autocommand
         events are ignored, autocommands will not be executed.
-
-        `:help eventignore`
+ 
       '';
     };
 
-    exrc = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    exrc = {
+      type = bool;
+      default = false;
       description = ''
         Automatically execute .nvim.lua, .nvimrc, and .exrc files in the
         current directory, if the file is in the |trust| list. Use |:trust| to
         manage trusted files.
-
-        `:help exrc`
-        `:help :trust`
+ 
       '';
+      extraHelp = [ ":trust" ];
     };
 
-    fileencodings = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression ''["ucs-bom" "utf-8" "default" "latin1"]'';
+    fileencodings = {
+      type = (listOf str);
+      default = ''["ucs-bom" "utf-8" "default" "latin1"]'';
       description = ''
         This is a list of character encodings considered when starting to edit
         an existing file.
-
-        `:help fileencodings`
+ 
       '';
     };
 
-    fileformats = mkOption {
-      type = nullOr (listOf (enum [ "dos" "unix" "mac" ]));
-      default = null;
-      defaultText = literalExpression ''
+    fileformats = {
+      type = (listOf (enum [ "dos" "unix" "mac" ]));
+      default = ''
         Windows default: ["dos" "unix"],
         Unix default: ["unix" "dos"]
       '';
@@ -746,55 +652,48 @@ let
         This gives the end-of-line (<EOL>) formats that will be tried when
         starting to edit a new buffer and when reading a file into an existing
         buffer
-
-        `:help fileformats`
+ 
       '';
     };
 
-    fileignorecase = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = ''
+    fileignorecase = {
+      type = bool;
+      default = ''
         `true` for systems where case in file names is normally ignored"
       '';
       description = ''
         When set case is ignored when using file names and directories.
-
-        `:help fileignorecase`
+ 
       '';
     };
 
-    foldclose = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    foldclose = {
+      type = str;
+      default = "";
       description = ''
         When set to "all", a fold is closed when the cursor isn't in it and
         its level is higher than 'foldlevel'.  Useful if you want folds to
         automatically close when moving out of them.
-
-        `:help foldclose`
+ 
       '';
     };
 
-    foldlevelstart = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "-1";
+    foldlevelstart = {
+      type = number;
+      default = -1;
       description = ''
         Sets 'foldlevel' when starting to edit another buffer in a window.
         Useful to always start editing with all folds closed (value zero),
         some folds closed (one) or no folds closed (99).
 
         When the value is negative, it is not used.
-
-        `:help foldlevelstart`
-        `:help foldlevel`
+ 
       '';
+      extraHelp = [ "foldlevel" ];
     };
 
-    foldopen = mkOption {
-      type = nullOr (listOf (enum [
+    foldopen = {
+      type = (listOf (enum [
         "all"
         "block"
         "hor"
@@ -807,8 +706,7 @@ let
         "tag"
         "undo"
       ]));
-      default = null;
-      defaultText = literalExpression ''
+      default = ''
         [
           "block"
           "hor"
@@ -824,315 +722,275 @@ let
         Specifies for which type of commands folds will be opened, if the
         command moves the cursor into a closed fold.  It is a comma-separated
         list of items.
-
-        `:help foldopen`
+ 
       '';
     };
 
-    fsync = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    fsync = {
+      type = bool;
+      default = true;
       description = ''
         When on, the OS function fsync() will be called after saving a file
         (|:write|, |writefile()|, …), |swap-file|, |undo-persistence| and |shada-file|.
         This flushes the file to disk, ensuring that it is safely written.
         Slow on some systems: writing buffers, quitting Nvim, and other
         operations may sometimes take a few seconds.
-
-        `:help fsync`;
+ 
       '';
     };
 
-    gdefault = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    gdefault = {
+      type = bool;
+      default = false;
       description = ''
         When on, the ":substitute" flag 'g' is default on.  This means that
         all matches in a line are substituted instead of one.  When a 'g' flag
         is given to a ":substitute" command, this will toggle the substitution
         of all or one match.  See |complex-change|.
-
-        `:help gdefault`
+ 
       '';
     };
 
-    grepformat = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = literalExpression ''%f:%l:%m,%f:%l%m,%f  %l%m'';
+    grepformat = {
+      type = str;
+      default = ''%f:%l:%m,%f:%l%m,%f  %l%m'';
       description = ''
         Format to recognize for the ":grep" command output.
-
-        `:help grepformat`
-        `:help errorformat`
+ 
       '';
+      extraHelp = [ "errorformat" ];
     };
 
-    guicursor = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "n-v-c-sm:block,i-ci-ve:ver25,r-cr-o:hor20";
+    guicursor = {
+      type = str;
+      default = "n-v-c-sm:block,i-ci-ve:ver25,r-cr-o:hor20";
       description = ''
         Configures the cursor style for each mode. Works in the GUI and many
         terminals.  See |tui-cursor-shape|.
 
         To disable cursor-styling, reset the option
-
-        `:help guicursor`
+ 
       '';
     };
 
-    guifont = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "[]";
+    guifont = {
+      type = (listOf str);
+      default = [ ];
       description = ''
         This is a list of fonts which will be used for the GUI version of Vim.
         In its simplest form the value is just one font name.  When
         the font cannot be found you will get an error message.  To try other
         font names a list can be specified, font names separated with commas.
         The first valid font is used.
-
-        `:help guifont`
+ 
       '';
     };
 
-    guifontwide = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "[]";
+    guifontwide = {
+      type = (listOf str);
+      default = [ ];
       description = ''
         list of fonts to be used for double-width characters.
         The first font that can be loaded is used.
-
-        `:help guifontwide`
+ 
       '';
     };
 
-    guioptions = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "egmrLT";
+    guioptions = {
+      type = str;
+      default = "egmrLT";
       description = ''
         This option only has an effect in the GUI version of Vim.  It is a
         sequence of letters which describes what components and options of the
         GUI should be used.
-
-        `:help guioptions`
+ 
       '';
     };
 
-    guitablabel = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    guitablabel = {
+      type = str;
+      default = "";
       description = ''
         When non-empty describes the text to use in a label of the GUI tab
         pages line.  When empty and when the result is empty Vim will use a
         default label.
-
-        `:help guitablabel`
-        `:help setting-guitablabel`
+ 
       '';
+      extraHelp = [ "setting-guitablabel" ];
     };
 
-    guitabtooltip = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    guitabtooltip = {
+      type = str;
+      default = "";
       description = ''
         When non-empty describes the text to use in a tooltip for the GUI tab
         pages line.  When empty Vim will use a default tooltip.
-
-        `:help guitabtooltip`
+ 
       '';
     };
 
-    helpfile = mkOption {
-      type = nullOr (either string path);
-      default = null;
-      defaultText = literalExpression ''
+    helpfile = {
+      type = (either str path);
+      default = ''
         default (MS-Windows) "$VIMRUNTIME\doc\help.txt"
                 (others) "$VIMRUNTIME/doc/help.txt"
-
-        `:help helpfile`
+ 
       '';
     };
 
-    helpheight = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "20";
+    helpheight = {
+      type = number;
+      default = 20;
       description = ''
         Minimal initial height of the help window when it is opened with the ":help" command.
-
-        `:help helpheight`
+ 
       '';
     };
 
-    helplang = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "messages language or empty";
+    helplang = {
+      type = (listOf str);
+      default = messages language or empty;
       description = ''
         list of languages.  Vim will use the first language
         for which the desired help can be found.
-
-        `:help helplang`
+ 
       '';
     };
 
-    hidden = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    hidden = {
+      type = bool;
+      default = true;
       description = ''
         When off a buffer is unloaded (including loss of undo information)
         when it is abandoned.  When on a buffer becomes hidden when it is
         abandoned.  A buffer displayed in another window does not become
         hidden, of course.
-
-        `:help hidden`
-        `:help abadon`
-        `:help bufhidden`
+ 
       '';
+      extraHelp = [
+        "abadon"
+        "bufhidden"
+      ];
     };
 
-    history = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "10000";
+    history = {
+      type = number;
+      default = 10000;
       description = ''
         A history of ":" commands, and a history of previous search patterns
         is remembered.  This option decides how many entries may be stored in
         each of these histories
 
         The maximum is 10000.
-
-        `:help history`
-        `:help cmdline-editing`
+ 
       '';
+      extraHelp = [ "cmdline-editing" ];
     };
 
-    hlsearch = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    hlsearch = {
+      type = bool;
+      default = true;
       description = ''
         When there is a previous search pattern, highlight all its matches.
-
-        `:help hlsearch`
-        `:help incsearch`
-        `:help match`
+ 
       '';
+      extraHelp = [
+        "incsearch"
+        "match"
+      ];
     };
 
-    icon = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    icon = {
+      type = bool;
+      default = false;
       description = ''
         When on, the icon text of the window will be set to the value of
-        'iconstring' (if it is not empty), or to the name of the file
+        'iconstr' (if it is not empty), or to the name of the file
         currently being edited.  Only the last part of the name is used.
-        Overridden by the 'iconstring' option.
+        Overridden by the 'iconstr' option.
         Only works if the terminal supports setting window icons.
-
-        `:help icon`
-        `:help iconstring`
+ 
       '';
+      extraHelp = [ "iconstring" ];
     };
 
-    iconstring = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    iconstring = {
+      type = str;
+      default = "";
       description = ''
         When this option is not empty, it will be used for the icon text of the window.
-
-        `:help iconstring`
+ 
       '';
     };
 
-    ignorecase = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = "false";
+    ignorecase = {
+      type = bool;
+      default = false;
       description = ''
         Ignore case in search patterns.  Also used when searching in the tags file.
 
         Also see 'smartcase' and 'tagcase'.
-
-        `:help ignorecase`
+ 
       '';
     };
 
-    imcmdline = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    imcmdline = {
+      type = bool;
+      default = false;
       description = ''
         When set the Input Method is always on when starting to edit a command
         line, unless entering a search pattern.
-
-        `:help imcmdline`
-        `:help imsearch`
+ 
       '';
+      extraHelp = [ "imsearch" ];
     };
 
-    imdisable = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "default false, true for some systems (SGI)";
+    imdisable = {
+      type = bool;
+      default = ''
+        false
+        true for some systems (SGI)
+      '';
       description = ''
         When set the Input Method is never used.  This is useful to disable
         the IM when it doesn't work properly.
-
-        `:help imdisable`
+ 
       '';
     };
 
-    inccommand = mkOption {
-      type = nullOr (enum [ "nosplit" "split" ]);
-      default = null;
-      defaultText = "nosplit";
+    inccommand = {
+      type = (enum [ "nosplit" "split" ]);
+      default = "nosplit";
       description = ''
         When nonempty, shows the effects of |:substitute|, |:smagic|,
         |:snomagic| and user commands with the |:command-preview| flag as you
         type.
-
-        `:help inccommand`
+ 
       '';
     };
 
-    incsearch = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    incsearch = {
+      type = bool;
+      default = true;
       description = ''
         While typing a search command, show where the pattern, as it was typed
-        so far, matches.  The matched string is highlighted.  If the pattern
+        so far, matches.  The matched str is highlighted.  If the pattern
         is invalid or not found, nothing is shown.
-
-        `:help incsearch`
+ 
       '';
     };
 
-    isfname = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = literalExpression ''
+    isfname = {
+      type = str;
+      default = ''
         Windows: "@,48-57,/,\,.,-,_,+,,,#,$,%,{,},[,],:,@-@,!,~,="
         otherwise: "@,48-57,/,.,-,_,+,,,#,$,%,~,="
       '';
     };
 
-    isident = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = literalExpression ''
+    isident = {
+      type = str;
+      default = ''
         Windows: "@,48-57,_,128-167,224-235"
         otherwise: "@,48-57,_,192-255"
       '';
@@ -1140,62 +998,53 @@ let
         The characters given by this option are included in identifiers.
         Identifiers are used in recognizing environment variables and after a
         match of the 'define' option.
-
-        `:help isident`
+ 
       '';
     };
 
-    isprint = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "@,161-255";
+    isprint = {
+      type = str;
+      default = "@,161-255";
       description = ''
         The characters given by this option are displayed directly on the
         screen.  It is also used for "\p" in a |pattern|.
-
-        `:help isprint`
-        `:help pattern`
+ 
       '';
+      extraHelp = [ "pattern" ];
     };
 
-    jumpoptions = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = ''
+    jumpoptions = {
+      type = str;
+      default = "";
+      description = ''
         List of words that change the behavior of the |jumplist|
-
-        `:help jumpoptions`
-        `:help jumplist`
+ 
       '';
+      extraHelp = [ "jumplist" ];
     };
 
-    joinspaces = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    joinspaces = {
+      type = bool;
+      default = false;
       description = ''
         Insert two spaces after a '.', '?' and '!' with a join command.
         Otherwise only one space is inserted.
-
-        `:help joinspaces`
+ 
       '';
     };
 
-    keymodel = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "[]";
+    keymodel = {
+      type = (listOf str);
+      default = [ ];
       description = ''
         List of comma-separated words, which enable special things that keys can do.
-
-        `:help keymodel`
+ 
       '';
     };
 
-    langmap = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = literalExpression "[]";
+    langmap = {
+      type = (listOf str);
+      default = [ ];
       description = ''
         This option allows switching your keyboard into a special language
         mode.  When you are typing text in Insert mode the characters are
@@ -1203,39 +1052,33 @@ let
         care of translating these special characters to the original meaning
         of the key.  This means you don't have to change the keyboard mode to
         be able to execute Normal mode commands.
-
-        `:help langmap`
+ 
       '';
     };
 
-    langmenu = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    langmenu = {
+      type = str;
+      default = "";
       description = ''
         Language to use for menu translation.
-
-        `:help langmenu`
+ 
       '';
     };
 
-    langremap = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    langremap = {
+      type = bool;
+      default = false;
       description = ''
         When off, setting 'langmap' does not apply to characters resulting from
         a mapping.  If setting 'langmap' disables some of your mappings, make
         sure this option is off.
-
-        `:help langremap`
+ 
       '';
     };
 
-    laststatus = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "2";
+    laststatus = {
+      type = number;
+      default = 2;
       description = ''
         The value of this option influences when the last window will have a
         status line:
@@ -1243,464 +1086,426 @@ let
         - 1: only if there are at least two windows
         - 2: always
         - 3: always and ONLY the last window
-
-        `:help laststatus`
+ 
       '';
     };
 
-    lazyredraw = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    lazyredraw = {
+      type = bool;
+      default = false;
       description = ''
         When this option is set, the screen will not be redrawn while
         executing macros, registers and other commands that have not been
         typed.  Also, updating the window title is postponed.  To force an
         update use |:redraw|.
-
-        `:help lazyredraw`
-        `:help :redraw`
+ 
       '';
+      extraHelp = [ ":redraw" ];
     };
 
-    linespace = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "0";
+    linespace = {
+      type = number;
+      default = 0;
       description = ''
         Number of pixel lines inserted between characters.  Useful if the font
         uses the full character cell height, making lines touch each other.
         When non-zero there is room for underlining.
-
-        `:help linespace`
+ 
       '';
     };
 
-    loadplugins = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    loadplugins = {
+      type = bool;
+      default = true;
       description = ''
         When on the plugin scripts are loaded when starting up |load-plugins|.
         This option can be reset in your |vimrc| file to disable the loading
         of plugins.
-
-        `:help loadplugins`
+ 
       '';
     };
 
-    magic = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    magic = {
+      type = bool;
+      default = true;
       description = ''
         Changes the special characters that can be used in search patterns.
         See |pattern|.
         WARNING: Switching this option off most likely breaks plugins!  That
         is because many patterns assume it's on and will fail when it's off.
-
-        `:help magic`
+ 
       '';
     };
 
-    makeef = mkOption {
-      type = nullOr (either string path);
-      default = null;
-      defaultText = "";
+    makeef = {
+      type = (either str path);
+      default = "";
       description = ''
         Name of the errorfile for the |:make| command (see |:make_makeprg|)
         and the |:grep| command.
         When it is empty, an internally generated temp file will be used.
         When "##" is included, it is replaced by a number to make the name
         unique.
-
-        `:help makeef`
+ 
       '';
     };
   };
 
   window = with lib; with types; sharedGlobalOrWindow // {
-    arabic = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    arabic = {
+      type = bool;
+      default = false;
       description = ''
         This option can be set to start editing Arabic text.
-
-        `:help arabic`
+ 
       '';
     };
 
-    breakindent = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    breakindent = {
+      type = bool;
+      default = false;
       description = ''
         Every wrapped line will continue visually indented (same amount of
         space as the beginning of that line), thus preserving horizontal blocks
         of text.
-
-        `:help breakindent`
+ 
       '';
     };
 
-    breakindentopt = mkOption {
-      type = nullOr commas;
-      default = null;
-      defaultText = literalExpression "[]";
+    breakindentopt = {
+      type = commas;
+      default = [ ];
       description = ''
         Settings for 'breakindent
-
-        `:help breakindentopt`
+ 
       '';
     };
 
-    colorcolumn = mkOption {
-      type = nullOr commas;
-      default = null;
-      defaultText = literalExpression "[]";
+    colorcolumn = {
+      type = commas;
+      default = [ ];
       description = ''
         'colorcolumn' is a comma-separated list of screen columns that are
         highlighted with ColorColumn |hl-ColorColumn|.  Useful to align
         text.  Will make screen redrawing slower.
-
-        `:help colorcolumn`
+ 
       '';
     };
 
-    foldcolumn = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "0";
+    concealcursor = {
+      type = str;
+      default = "";
+      description = ''
+        Sets the modes in which text in the cursor line can also be concealed.
+ 
+      '';
+    };
+
+    conceallevel = {
+      type = number;
+      default = 0;
+      description = ''
+        Determine how text with the "conceal" syntax attribute |:syn-conceal|
+        is shown
+ 
+      '';
+      extraHelp = [ "syn-conceal" ];
+    };
+
+    cursorbind = {
+      type = bool;
+      default = false;
+      description = ''
+        When this option is set, as the cursor in the current
+        window moves other cursorbound windows (windows that also have
+        this option set) move their cursors to the corresponding line and
+        column.
+ 
+      '';
+    };
+
+    foldcolumn = {
+      type = str;
+      default = "0";
       description = ''
         When and how to draw the foldcolumn. Valid values are:
             "auto":       resize to the minimum amount of folds to display.
             "auto:[1-9]": resize to accommodate multiple folds up to the selected level
             "0":          to disable foldcolumn
             "[1-9]":      to display a fixed number of columns
-
-        `:help foldcolumn`
-        `:help folding`
+ 
       '';
+      extraHelp = [ "folding" ];
     };
 
-    foldenable = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    foldenable = {
+      type = bool;
+      default = false;
       description = ''
         When off, all folds are open.  This option can be used to quickly
         switch between showing all text unfolded and viewing the text with
         folds (including manually opened or closed folds).  It can be toggled
         with the |zi| command.  The 'foldcolumn' will remain blank when
         'foldenable' is off.
-
-        `:help foldenable`
-        `:help folding`
+ 
       '';
+      extraHelp = [ "folding" ];
     };
 
-    foldexpr = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "0";
+    foldexpr = {
+      type = str;
+      default = "0";
       description = ''
         The expression used for when 'foldmethod' is "expr".  It is evaluated
         for each line to obtain its fold level.
-
-        `:help foldexpr`
-        `:help fold-expr`
+ 
       '';
+      extraHelp = [ "fold-expr" ];
     };
 
-    foldignore = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "#";
+    foldignore = {
+      type = str;
+      default = "#";
       description = ''
         Used only when 'foldmethod' is "indent".  Lines starting with
         characters in 'foldignore' will get their fold level from surrounding
         lines.  White space is skipped before checking for this character.
-
-        `:help foldignore`
-        `:help fold-indent`
+ 
       '';
+      extraHelp = [ "fold-indent" ];
     };
 
-    foldlevel = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "0";
+    foldlevel = {
+      type = number;
+      default = 0;
       description = ''
         Sets the fold level: Folds with a higher level will be closed.
         Setting this option to zero will close all folds.  Higher numbers will
         close fewer folds.
         This option is set by commands like |zm|, |zM| and |zR|.
-
-        `:help foldlevel`
-        `:help fold-foldlevel`
+ 
       '';
+      extraHelp = [ "fold-foldlevel" ];
     };
 
-    foldmarker = mkOption {
-      type = nullOr (listOf string);
+    foldmarker = {
+      type = (listOf str);
       apply = x: assert (x == null || builtins.length x == 2 || abort "`foldmarker` must contain start and end markers in the list"); x;
-      default = null;
-      defaultText = literalExpression ''["{{{" "}}}"]'';
+      default = ''["{{{" "}}}"]'';
       description = ''
         The start and end marker used when 'foldmethod' is "marker".
-
-        `:help foldmarker`
+ 
       '';
     };
 
-    foldmethod = mkOption {
-      type = nullOr (enum [ "manual" "indent" "expr" "marker" "syntax" "diff" ]);
-      default = null;
-      defaultText = "manual";
+    foldmethod = {
+      type = (enum [ "manual" "indent" "expr" "marker" "syntax" "diff" ]);
+      default = "manual";
       description = ''
         The kind of folding used for the current window.
-
-        `:help foldmethod`
-        `:help fold-manual`
-        `:help fold-indent`
-        `:help fold-expr`
-        `:help fold-marker`
-        `:help fold-syntax`
-        `:help fold-diff`
       '';
+      extraHelp = [
+        "fold-manual"
+        "fold-indent"
+        "fold-expr"
+        "fold-marker"
+        "fold-syntax"
+        "fold-diff"
+      ];
     };
 
-    foldminlines = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "1";
+    foldminlines = {
+      type = number;
+      default = 1;
       description = ''
         Sets the number of screen lines above which a fold can be displayed
         closed.  Also for manually closed folds.
-
-        `:help foldminlines`
+ 
       '';
     };
 
-    foldnestmax = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "20";
+    foldnestmax = {
+      type = number;
+      default = 20;
       description = ''
         Sets the maximum nesting of folds for the "indent" and "syntax"
         methods.  This avoids that too many folds will be created.  Using more
         than 20 doesn't work, because the internal limit is 20.
-
-        `:help foldnestmax`
+ 
       '';
     };
 
-    foldtext = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "foldtext()";
+    foldtext = {
+      type = str;
+      default = "foldtext()";
       description = ''
         An expression which is used to specify the text displayed for a closed fold.
-
-        `:help foldtext`
-        `:help fold-foldtext`
+ 
       '';
+      extraHelp = [ "fold-foldtext" ];
     };
 
-    linebreak = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    linebreak = {
+      type = bool;
+      default = false;
       description = ''
         If on, Vim will wrap long lines at a character in 'breakat' rather
         than at the last character that fits on the screen.  Unlike
         'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file,
         it only affects the way the file is displayed, not its contents.
-
-        `:help linebreak`
+ 
       '';
     };
 
-    list = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = "false";
+    list = {
+      type = bool;
+      default = false;
       description = ''
         List mode: By default, show tabs as ">", trailing spaces as "-", and
         non-breakable space characters as "+". Useful to see the difference
         between tabs and spaces and for trailing blanks. Further changed by
         the 'listchars' option.
-
-        `:help list`
-        `:help listchars`
+ 
       '';
+      extraHelp = [ "listchars" ];
     };
 
-    listchars = mkOption {
+    listchars = {
       type = submodule {
         options =
           let
-            inherit (builtins) stringLength;
-            mkOption = { description, min ? 1, max ? 1 }: with lib; lib.mkOption {
-              type = types.nullOr types.string;
-              default = null;
+            inherit (builtins) strLength;
+            mkListcharsOption = k: { description, min ? 1, max ? 1 }: mkVimOptOption k {
+              type = lib.types.str;
               apply = x:
                 assert (
-                  (stringLength x >= min && stringLength x <= max)
+                  (strLength x >= min && strLength x <= max)
                     || abort ''
                     The number of characters ${x} does not correspond to the boundaries
-                    (min: ${toString min}; max: ${toString max})
+                    (min: ${tostr min}; max: ${tostr max})
                   ''
                 );
                 x;
               inherit description;
             };
           in
-          {
-            eol = mkOption {
+          (mapAttrs mkListcharsOption {
+            eol = {
               description = ''
                 Character to show at the end of each line.  When
                 omitted, there is no extra character at the end of the
                 line.
-
-                `:help lcs-eol`
               '';
             };
 
-            tab = mkOption {
+            tab = {
               description = ''
                 Two or three characters to be used to show a tab.
                 The third character is optional.
-
-                `:help lcs-tab`
               '';
               max = 3;
             };
 
-            space = mkOption {
+            space = {
               description = ''
                 Character to show for a space.  When omitted, spaces are left blank.
-
-                `:help lcs-space`
               '';
             };
 
-            multispace = mkOption {
+            multispace = {
               description = ''
                 One or more characters to use cyclically to show for
                 multiple consecutive spaces.  Overrides the "space"
                 setting, except for single spaces.
-
-                `:help lcs-multispace`
               '';
               max = 99;
             };
 
-            lead = mkOption {
+            lead = {
               description = ''
                 Character to show for leading spaces.  When omitted,
                 leading spaces are blank.  Overrides the "space" and
                 "multispace" settings for leading spaces.
-
-                `:help lcs-lead`
+ 
               '';
             };
 
-            leadmultispace = mkOption {
+            leadmultispace = {
               description = ''
                 Like the |lcs-multispace| value, but for leading
                 spaces only.  Also overrides |lcs-lead| for leading
                 multiple spaces.
-
-                `:help lcs-leadmultispace`
               '';
               max = 99;
             };
 
-            trail = mkOption {
+            trail = {
               description = ''
                 Character to show for trailing spaces.  When omitted,
                 trailing spaces are blank.  Overrides the "space" and
                 "multispace" settings for trailing spaces.
-
-                `:help lcs-trail`
               '';
             };
 
-            extends = mkOption {
+            extends = {
               description = ''
                 Character to show in the last column, when 'wrap' is
                 off and the line continues beyond the right of the
                 screen.
-
-                `:help lcs-extends`
               '';
             };
 
-            precedes = mkOption {
+            precedes = {
               description = ''
                 Character to show in the first visible column of the
                 physical line, when there is text preceding the
                 character visible in the first column.
-
-                `:help lcs-precedes`
               '';
             };
 
-            conceal = mkOption {
+            conceal = {
               description = ''
                 Character to show in place of concealed text, when
                 'conceallevel' is set to 1.  A space when omitted.
-
-                `:help lcs-conceal`
               '';
             };
 
-            nbsp = mkOption {
+            nbsp = {
               description = ''
                 Character to show for a non-breakable space character
                 (0xA0 (160 decimal) and U+202F).
-
-                `:help nbsp`
               '';
             };
-          };
+          });
       };
     };
   };
 
   buffer = with lib; with types; sharedGlobalOrBuffer // {
-    autoindent = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    autoindent = {
+      type = bool;
+      default = true;
       description = ''
         Copy indent from current line when starting a new line (typing <CR>
         in Insert mode or when using the "o" or "O" command).  If you do not
         type anything on the new line except <BS> or CTRL-D and then type
         <Esc>, CTRL-O or <CR>, the indent is deleted again.
-
-        `:help autoindent`
+ 
       '';
     };
 
-    binary = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    binary = {
+      type = bool;
+      default = false;
       description = ''
         This option should be set before editing a binary file.  You can also
         use the |-b| Vim argument.
-
-        `:help binary`
       '';
     };
 
-    bomb = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    bomb = {
+      type = bool;
+      default = false;
       description = ''
         When writing a file and the following conditions are met, a BOM (Byte
         Order Mark) is prepended to the file:
@@ -1708,113 +1513,94 @@ let
         - the 'binary' option is off
         - 'fileencoding' is "utf-8", "ucs-2", "ucs-4" or one of the little/big
           endian variants.
-
-        `:help bomb`
+ 
       '';
     };
 
-    bufhidden = mkOption {
-      type = nullOr (enum [ "" "hide" "unload" "delete" "wipe" ]);
-      default = null;
-      defaultText = "";
+    bufhidden = {
+      type = (enum [ "" "hide" "unload" "delete" "wipe" ]);
+      default = "";
       description = ''
         This option specifies what happens when a buffer is no longer
         displayed in a window
-
-        `:help bufhidden`
+ 
       '';
     };
 
-    buflisted = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    buflisted = {
+      type = bool;
+      default = true;
       description = ''
         When this option is set, the buffer shows up in the buffer list.
-
-        `:help buflisted`
+ 
       '';
     };
 
-    buftype = mkOption {
-      type = nullOr (enum [ "" "acwrite" "help" "nofile" "nowrite" "quickfix" "terminal" "prompt" ]);
-      default = null;
-      defaultText = "";
+    buftype = {
+      type = (enum [ "" "acwrite" "help" "nofile" "nowrite" "quickfix" "terminal" "prompt" ]);
+      default = "";
       description = ''
         This option is used together with 'bufhidden' and 'swapfile' to
         specify special kinds of buffers.
-
-        `:help buftype`
-        `:help special-buffers`
+ 
       '';
+      extraHelp = [ "special-buffers" ];
     };
 
-    cindent = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    cindent = {
+      type = bool;
+      default = false;
       description = ''
         Enables automatic C program indenting.
-
-        `:help cindent`
+ 
       '';
     };
 
-    cinkeys = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "0{,0},0),0],:,0#,!^F,o,O,e";
+    cinkeys = {
+      type = str;
+      default = "0{,0},0),0],:,0#,!^F,o,O,e";
       description = ''
         A list of keys that, when typed in Insert mode, cause reindenting of
         the current line.
-
-        `:help cinkeys`
+ 
       '';
     };
 
-    cinoptions = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    cinoptions = {
+      type = str;
+      default = "";
       description = ''
         The 'cinoptions' affect the way 'cindent' reindents lines in a C
         program.
-
-        `:help cinoptions`
-        `:help cinoptions-values`
       '';
+      extraHelp = [ "cinoptions-values" ];
     };
 
-    cinwords = mkOption {
-      type = nullOr commas;
-      default = null;
-      defaultText = literalExpression ''["if" "else" "while" "do" "for" "switch"]'';
+    cinwords = {
+      type = commas;
+      default = ''["if" "else" "while" "do" "for" "switch"]'';
       descrpition = ''
         These keywords start an extra indent in the next line when
         'smartindent' or 'cindent' is set.  For 'cindent' this is only done at
         an appropriate place (inside {}).
-
-        `:help cinwords`
+ 
       '';
     };
 
-    cinscopedecls = mkOption {
-      type = nullOr commas;
-      default = null;
-      defaultText = literalExpression ''["public" "protected" "private"]'';
+    cinscopedecls = {
+      type = commas;
+      default = ''["public" "protected" "private"]'';
       descrpition = ''
         Keywords that are interpreted as a C++ scope declaration by |cino-g|.
         Useful e.g. for working with the Qt framework that defines additional
         scope declarations "signals", "public slots" and "private slots"
-
-        `:help cinscopedecls`
+ 
       '';
     };
 
-    comments = mkOption {
-      type = nullOr commas;
-      default = null;
-      defaultText = literalExpression ''
+    comments = {
+      type = commas;
+      default = ''
         [
           "s1/*"
           "mb:8"
@@ -1828,17 +1614,70 @@ let
         ]
       '';
       description = ''
-        list of strings that can start a comment line.
-
-        `:help comments`
-        `:help format-comments`
+        list of strs that can start a comment line.
+ 
       '';
+      extraHelp = [ "format-comments" ];
     };
 
-    expandtab = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    commentstring = {
+      type = str;
+      default = "";
+      description = ''
+        A template for a comment.  The "%s" in the value is replaced with the
+        comment text.  Currently only used to add markers for folding, see
+        |fold-marker|.
+ 
+      '';
+      extraHelp = [ "fold-marker" ];
+    };
+
+    complete = {
+      type = commas;
+      default = ''["." "w" "b" "u" "t"]'';
+      description = ''
+        This option specifies how keyword completion |ins-completion| works
+        when CTRL-P or CTRL-N are used.
+ 
+      '';
+      extraHelp = [ "ins-completion" ];
+    };
+
+    completefunc = {
+      type = str;
+      default = "";
+      description = ''
+        This option specifies a function to be used for Insert mode completion
+        with CTRL-X CTRL-U.
+ 
+      '';
+      extraHelp = [
+        "complete-functions"
+        "i_CTRL-X_CTRL-U"
+      ];
+    };
+
+    copyindent = {
+      type = bool;
+      default = false;
+      description = ''
+        Copy the structure of the existing lines indent when autoindenting a
+        new line.  Normally the new indent is reconstructed by a series of
+        tabs followed by spaces as required (unless |'expandtab'| is enabled,
+        in which case only spaces are used).  Enabling this option makes the
+        new line copy whatever characters were used for indenting on the
+        existing line.
+ 
+      '';
+      extraHelp = [
+        "expandtab"
+        "preverseindent"
+      ];
+    };
+
+    expandtab = {
+      type = bool;
+      default = false;
       description = ''
         In Insert mode: Use the appropriate number of spaces to insert a
         <Tab>.  Spaces are used in indents with the '>' and '<' commands and
@@ -1847,10 +1686,9 @@ let
       '';
     };
 
-    fileencoding = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    fileencoding = {
+      type = str;
+      default = "";
       description = ''
         File-content encoding for the current buffer. Conversion is done with
         iconv() or as specified with 'charconvert'.
@@ -1859,15 +1697,13 @@ let
         writing the file.  For reading see below.
         When 'fileencoding' is empty, the file will be saved with UTF-8
         encoding (no conversion when reading or writing a file).
-
-        `:help fileencoding`
+ 
       '';
     };
 
-    fileformat = mkOption {
-      type = nullOr (enum [ "dos" "unix" "mac" ]);
-      default = null;
-      defaultText = literalExpression ''
+    fileformat = {
+      type = (enum [ "dos" "unix" "mac" ]);
+      default = ''
         Windows default: "dos",
         Unix default: "unix"
       '';
@@ -1881,9 +1717,8 @@ let
       '';
     };
 
-    filetype = mkOption {
-      type = nullOr string;
-      default = null;
+    filetype = {
+      type = str;
       description = ''
         When this option is set, the FileType autocommand event is triggered.
 
@@ -1892,91 +1727,80 @@ let
         this use the ":filetype on" command. |:filetype|
 
         When a dot appears in the value then this separates two filetype names.
-
-        `:help filetype`
-        `:help :filetype`
+ 
       '';
-
+      extraHelp = [ ":filetype" ];
     };
 
-    fixendofline = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "true";
+    fixendofline = {
+      type = bool;
+      default = true;
       description = ''
         When writing a file and this option is on, <EOL> at the end of file
         will be restored if missing.  Turn this option off if you want to
         preserve the situation from the original file.
         When the 'binary' option is set the value of this option doesn't
         matter.
-
-        `:help fixendofline`
-        `:help binary`
-        `:help endofline`
-        `:help eol-and-eof`
+ 
       '';
+      extraHelp = [
+        "binary"
+        "endofline"
+        "eol-and-eof"
+      ];
     };
 
-    formatexpr = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    formatexpr = {
+      type = str;
+      default = "";
       description = ''
         Expression which is evaluated to format a range of lines for the |gq|
         operator or automatic formatting (see 'formatoptions').  When this
         option is empty 'formatprg' is used.
-
-        `:help formatexpr`
+ 
       '';
     };
 
-    formatlistpat = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = ''^\s*\d\+[\]:.)}\t ]\s*'';
+    formatlistpat = {
+      type = str;
+      default = ''^\s*\d\+[\]:.)}\t ]\s*'';
       description = ''
         A pattern that is used to recognize a list header.  This is used for
         the "n" flag in 'formatoptions'.
 
         The default recognizes a number, followed by an optional punctuation
-
-        `:help formatlistpat`
-        `:help formatoptions`
+ 
       '';
+      extraHelp = [ "formatoptions" ];
     };
 
-    formatoptions = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "tcqj";
+    formatoptions = {
+      type = str;
+      default = "tcqj";
       description = ''
         This is a sequence of letters which describes how automatic
         formatting is to be done.
-
-        `:help formatoptios`
-        `:help fo-table`
+ 
       '';
+      extraHelp = [ "fo-table" ];
     };
 
-    iminsert = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "0";
+    iminsert = {
+      type = number;
+      default = 0;
       description = ''
         Specifies whether :lmap or an Input Method (IM) is to be used in
         Insert mode.  Valid values:
         - 0   :lmap is off and IM is off
         - 1   :lmap is ON and IM is off
         - 2   :lmap is off and IM is ON
-
-        `:help iminsert`
+ 
       '';
     };
 
-    imsearch = mkOption {
-      type = nullOr number;
-      default = null;
-      defaultText = literalExpression "-1";
+    imsearch = {
+      type = number;
+      default = -1;
       description = ''
         Specifies whether :lmap or an Input Method (IM) is to be used when
         entering a search pattern.  Valid values:
@@ -1985,106 +1809,89 @@ let
         - 0   :lmap is off and IM is off
         - 1   :lmap is ON and IM is off
         - 2   :lmap is off and IM is ON
-
-        `:help imsearch`
+ 
       '';
     };
 
-    includexpr = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    includexpr = {
+      type = str;
+      default = "";
       description = ''
-        Expression to be used to transform the string found with the 'include'
+        Expression to be used to transform the str found with the 'include'
         option to a file name.
-
-        `:help includexpr`
+ 
       '';
     };
 
-    indentexpr = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    indentexpr = {
+      type = str;
+      default = "";
       description = ''
         Expression which is evaluated to obtain the proper indent for a line.
         It is used when a new line is created, for the |=| operator and
         in Insert mode as specified with the 'indentkeys' option.
-
-        `:help indentexpr`
+ 
       '';
     };
 
-    indentkeys = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "0{,0},0),0],:,0#,!^F,o,O,e";
+    indentkeys = {
+      type = str;
+      default = "0{,0},0),0],:,0#,!^F,o,O,e";
       description = ''
         A list of keys that, when typed in Insert mode, cause reindenting of
         the current line.
-
-        `:help indentkeys`
+ 
       '';
     };
 
-    infercase = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    infercase = {
+      type = bool;
+      default = false;
       description = ''
         When doing keyword completion in insert mode |ins-completion|, and
         'ignorecase' is also on, the case of the match is adjusted depending
         on the typed text.  If the typed text contains a lowercase letter
         where the match has an upper case letter, the completed part is made
         lowercase.
-
-        `:help infercase`
+ 
       '';
     };
 
-    iskeyward = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "@,48-57,_,192-255";
+    iskeyward = {
+      type = str;
+      default = "@,48-57,_,192-255";
       description = ''
         Keywords are used in searching and recognizing with many commands:
         "w", "*", "[i", etc.  It is also used for "\k" in a |pattern|.
-
-        `:help iskeyword`
-        `:help pattern`
+ 
       '';
-
+      extraHelp = [ "pattern" ];
     };
 
-    keymap = mkOption {
-      type = nullOr string;
-      default = null;
-      defaultText = "";
+    keymap = {
+      type = str;
+      default = "";
       description = ''
         Name of a keyboard mapping.
-
-        `:help keymap`
-        `:help mbyte-keymap`
+ 
       '';
+      extraHelp = [ "mbyte-keymap" ];
     };
 
-    lisp = mkOption {
-      type = nullOr bool;
-      default = null;
-      defaultText = literalExpression "false";
+    lisp = {
+      type = bool;
+      default = false;
       description = ''
         Lisp mode: When <Enter> is typed in insert mode set the indent for
         the next line to Lisp standards (well, sort of).  Also happens with
         "cc" or "S".
-
-        `:help lisp`
+ 
       '';
     };
 
-    lispoptions = mkOption {
-      type = nullOr (listOf string);
-      default = null;
-      defaultText = listExpression "[]";
+    lispoptions = {
+      type = (listOf str);
+      default = [ ];
       description = ''
         list of items that influence the Lisp indenting when
         enabled with the |'lisp'| option.  Currently only one item is
@@ -2092,13 +1899,10 @@ let
 
         - expr:1	use 'indentexpr' for Lisp indenting when it is set
         - expr:0	do not use 'indentexpr' for Lisp indenting (default)
-
-        `:help lispoptions`
       '';
     };
   };
 in
-{
+mapAttrs (_: mapAttrs mkVimOptOption) {
   inherit global window buffer;
-  all = global // window // buffer;
 }