bangedorrunt/macros.fnl

## macros.fnl
;;;; Helper Functions Declaration
;; (import-macros {: defn
;;                 : into
;;                 : empty
;;                 : when-let
;;                 : if-let
;;                 : when-some
;;                 : if-some} :cljlib.macros)

(local {: inc
        : dec
        : first
        : last
        : rest
        : any?
        : every?
        :some some?
        : keys
        : vals
        : reduce
        : reduce-kv
        : merge
        :mapv map
        : filter
        : string?
        : number?
        : nil?
        : contains?
        ;; :map? tbl?
        ;; : set?
        ;; :vector? seq?
        ;; : vector
        : empty?
        : cons
        : conj
        : dissoc} (require :cljlib))

;; (local {: format} string)

;; Reserve name for `into` macros
;; tbl->seq
;; seq->tbl
;; str->seq

(fn ->str [obj]
  "Converts an object to its string representation"
  (tostring obj))

(fn str->seq [s]
  "Convert an string into a sequence of characters."
  (icollect [c (string.gmatch s ".")]
    c))

;; (fn ->key-opts [seq]
;;   "Returns a set following the structure of `{:key true}` from a sequence"
;;   (reduce #(merge $1 {$2 true}) {} seq))

(fn ->key-opts [xs]
  "Convert a sequence into a table of each value of the sequence as the
  key and the value being `true`."
  (collect [_ v (ipairs xs)]
    (values v true)))

(fn fn? [obj]
  "Returns true if the object is a function
  This only works at compilation time"
  (and (list? obj) (or (= (->str (first obj)) :hashfn)
                       (= (->str (first obj)) :fn))))

(fn exists? [module-name]
  "Returns true if the module exists and false if it doesn't"
  (let [(ok? _) (pcall require module-name)]
    ok?))

;;; Macros Declaration

;; NOTE: https://github.com/rktjmp/hotpot.nvim/discussions/6
;; Put Unique Global
;;
;; (val :any prefix? :string) -> (uuid :string)
;;
;; Takes any given value, generates a unique name (with optional prefix)
;; and inserts value into _G. Returns unique name.
(fn pug [val prefix?]
  ;; gensym will generate a unique id across a compile pass, but hotpot/aniseed
  ;; may compile files in separate passes as they are modified, so symbols may
  ;; collide you can avoid this by passing a unique prefix per-file or using
  ;; something like the "uid" below, based on compile time
  (let [inter-compile-uid (_G.os.date "%s")
        name (if prefix?
                  (.. (->str (gensym prefix?)) inter-compile-uid)
                  (.. (->str (gensym :pug)) inter-compile-uid))]
  `(do
     (tset _G ,name ,val)
     ,name)))

;; Wrap given in v:lua x pug call
(fn vlua [what prefix?]
  `(.. "v:lua." ,(pug what prefix?) "()"))

;; BUG: `vlua` seems to have side-effect with `aniseed` plugin
;; current version using gensym doesn't evaluate `vlua` at runtime
(fn command! [name expr]
  (let [name (->str name)]
     (if (fn? expr)
       `(vim.cmd (string.format "command! %s call %s" ,name ,(vlua expr)))
       `(vim.cmd (string.format "command! %s %s" ,name ,expr)))))

(fn buf-command! [name expr]
  (let [name (->str name)]
     (if (fn? expr)
       `(vim.cmd (string.format "command! -buffer %s call %s" ,name ,(vlua expr)))
       `(vim.cmd (string.format "command! -buffer %s %s" ,name ,expr)))))

;; (fn command! [name f]
;;   `(vim.cmd ,(string.format "command! %s %s" (->str name) (->str f))))

;; (fn buf-command! [name f]
;;   `(vim.cmd ,(string.format "command! -buffer %s %s" (->str name) (->str f))))

(fn lua-command! [name f]
  (let [f (.. "lua " (->str f))]
    `(command! ,name ,f)))

(fn lua-buf-command! [name f]
  (let [f (.. "lua " (->str f))]
    `(buf-command! ,name ,f)))

(fn unless [condition ...]
  "Takes a single condition and evaluates the rest as a body if it's nil or
  false. This is intended for side-effects."
  `(when (not ,condition)
     ,...))

(fn set! [...]
  "Set one or multiple vim options using the `vim.opt` API
  The option name must be a symbol
  If the option doesn't have a corresponding value, if it begins with no the
  value becomes false, and if it doesn't it becomes true"
  (fn expr [name ?value]
    (let [name (->str name)
          value (if (nil? ?value) (not (name:match :^no)) ?value)
          name (if (nil? ?value) (or (name:match "^no(.*)$") name) name)]
      (if (fn? value)
          `(tset vim.opt ,name (string.format "%s" ,(vlua value)))
          (match (name:sub -1)
            "+" `(: (. vim.opt ,(name:sub 1 -2)) :append ,value)
            "-" `(: (. vim.opt ,(name:sub 1 -2)) :remove ,value)
            "^" `(: (. vim.opt ,(name:sub 1 -2)) :prepend ,value)
            _ `(tset vim.opt ,name ,value)))))

  (fn exprs [...]
    (match [...]
      (where [& rest] (empty? rest)) []
      (where [name value & rest] (not (sym? value)))
      [(expr name value) (unpack (exprs (unpack rest)))]
      [name & rest] [(expr name) (unpack (exprs (unpack rest)))]
      _ []))

  (let [exprs (exprs ...)]
    (if (> (length exprs) 1)
        `(do
           ,(unpack exprs))
        (unpack exprs))))

(fn set-local! [...]
  "Set a local vim option using the `vim.opt_local` API"
  (fn expr [name ?value]
    (let [name (->str name)
          value (if (nil? ?value) (not (name:match :^no)) ?value)
          name (if (nil? ?value) (or (name:match "^no(.*)$") name) name)]
      (if (fn? value)
          `(tset vim.opt_local ,name (string.format "%s" ,(vlua value)))
          (match (name:sub -1)
            "+" `(: (. vim.opt_local ,(name:sub 1 -2)) :append ,value)
            "-" `(: (. vim.opt_local ,(name:sub 1 -2)) :remove ,value)
            "^" `(: (. vim.opt_local ,(name:sub 1 -2)) :prepend ,value)
            _ `(tset vim.opt_local ,name ,value)))))

  (fn exprs [...]
    (match [...]
      (where [& rest] (empty? rest)) []
      (where [name value & rest] (not (sym? value)))
      [(expr name value) (unpack (exprs (unpack rest)))]
      [name & rest] [(expr name) (unpack (exprs (unpack rest)))]
      _ []))

  (let [exprs (exprs ...)]
    (if (> (length exprs) 1)
        `(do
           ,(unpack exprs))
        (unpack exprs))))

(fn let! [...]
  "Set a vim variable using the vim.[g b w t] API"
  (fn expr [name value]
    (let [name (->str name)
          scope (when (contains? [:g/ :b/ :w/ :t/] (name:sub 1 2))
                  (name:sub 1 1))
          name (if (nil? scope) name (name:sub 3))]
      `(tset ,(match scope
                :b `vim.b
                :w `vim.w
                :t `vim.t
                _ `vim.g) ,name ,value)))

  (fn exprs [...]
    (match [...]
      (where [& rest] (empty? rest)) []
      [name value & rest] [(expr name value) (unpack (exprs (unpack rest)))]
      _ []))

  (let [exprs (exprs ...)]
    (if (> (length exprs) 1)
        `(do
           ,(unpack exprs))
        (unpack exprs))))

(fn augroup! [name ...]
  "Defines an autocommand group using the `vim.cmd` API."
  `(do
     ,(unpack
        (-> [`(vim.cmd ,(string.format "augroup %s" name))
             `(vim.cmd "autocmd!")]
            (conj ...)
            (conj `(vim.cmd "augroup END"))))))

(fn buf-augroup! [name ...]
  "Defines a buffer-local autocommand group using the `vim.cmd` API."
  `(do
     ,(unpack
        (-> [`(vim.cmd ,(string.format "augroup %s" name))
             `(vim.cmd "autocmd! * <buffer>")]
            (conj ...)
            (conj `(vim.cmd "augroup END"))))))

(fn autocmd! [events pattern command]
  "Defines an autocommand"
  (let [events (if (sequence? events) events [events])
        events (-> (map ->str events)
                   (table.concat ","))
        pattern (if (sequence? pattern) pattern [pattern])
        pattern (-> (map ->str pattern)
                    (table.concat ","))]
    (if (fn? command)
        `(vim.cmd (string.format "autocmd %s %s call %s" ,events ,pattern
                                 ,(vlua command)))
        `(vim.cmd (string.format "autocmd %s %s %s" ,events ,pattern ,command)))))

(fn buf-autocmd! [events command]
  "Defines an autocommand"
  (let [events (if (sequence? events) events [events])
        events (-> (map ->str events)
                   (table.concat ","))]
    (if (fn? command)
        `(vim.cmd (string.format "autocmd %s <buffer> call %s" ,events
                                 ,(vlua command)))
        `(vim.cmd (string.format "autocmd %s <buffer> %s" ,events ,command)))))

(fn wk-map! [mode
             lhs
             {:buffer buffer?
              :silent silent?
              :noremap noremap?
              :nowait nowait?}
             description]
  "A mapping using which-key"
  `(let [(ok?# which-key#) (pcall require :which-key)]
     (when ok?#
       (which-key#.register {,lhs ,description}
                            {:mode ,mode
                             :buffer ,(if buffer? 0)
                             :silent ,(if silent? true)
                             :noremap ,(if (not noremap?) false)
                             :nowait ,(if nowait? true)}))))

(fn nmap! [[modes & options] lhs rhs ?description]
  "Defines a vim mapping using the `vim.api.nvim_set_keymap` API or the
  `vim.api.nvim_buf_set_keymap` if the option `:buffer` was passed.
  Support all the options the API supports.
  If the `rhs` argument is a function then automatically includes the `:expr`
  option."
  (fn nvim-set-keymap [mode lhs rhs options]
    (let [buffer? (?. options :buffer)
          options (dissoc options :buffer)]
      (if buffer?
        `(vim.api.nvim_buf_set_keymap 0 ,mode ,lhs ,rhs ,options)
        `(vim.api.nvim_set_keymap ,mode ,lhs ,rhs ,options))))

  (fn is-rhs-a-fn? [rhs]
    (if (fn? rhs)
        (vlua rhs)
        rhs))

  (let [modes (-> modes
                  ->str
                  str->seq)
        options
                  (if (fn? rhs)
                      (conj options :expr)
                      options)
        options          (->key-opts options)
        exprs (map #(nvim-set-keymap $ lhs (is-rhs-a-fn? rhs) options) modes)
        exprs (if (and ?description (exists? :which-key))
                  (conj exprs (unpack (map #(wk-map! $ lhs options ?description) modes)))
                  exprs)]
    (if (> (length exprs) 1)
        `(do
           ,(unpack exprs))
        (unpack exprs))))

(fn noremap! [[modes & options] lhs rhs ?description]
  "Defines a vim mapping using the `vim.api.nvim_set_keymap` API or the
  `vim.api.nvim_buf_set_keymap` if the option `:buffer` was passed.
  Support all the options the API supports.
  If the `rhs` argument is a function then automatically includes the `:expr`
  option.
  Automatically includes the `:noremap` option."
  (let [options (cons :noremap options)]
    `(nmap! ,(cons modes options) ,lhs ,rhs ,?description)))

(fn buf-nmap! [[modes & options] lhs rhs ?description]
  "Defines a vim mapping using the `vim.api.nvim_buf_set_keymap` if the option
  `:buffer` was passed.
  Support all the options the API supports.
  If the `rhs` argument is a function then automatically includes the `:expr`
  option."
  (let [options (cons :buffer options)]
    `(nmap! ,(cons modes options) ,lhs ,rhs ,?description)))

(fn buf-noremap! [[modes & options] lhs rhs ?description]
  "Defines a vim mapping using the `vim.api.nvim_buf_set_keymap` if the option
  `:buffer` was passed.
  Support all the options the API supports.
  If the `rhs` argument is a function then automatically includes the `:expr`
  option.
  Automatically includes the `:noremap` option."
  (let [options (->> options
                     (cons :buffer)
                     (cons :noremap))]
    `(nmap! ,(cons modes options) ,lhs ,rhs ,?description)))

(fn hi! [group opts]
  "Defines a highlight"
  (let [f (fn [k v]
            (match k
              :fg (let [fg (. opts :fg)]
                    `(.. :ctermfg= ,fg " guifg=" ,fg))
              :bg (let [bg (. opts :bg)]
                    `(.. :ctermbg= ,bg " guibg=" ,bg))
              _ `(.. ,(->str k) "=" ,v)))
        args (reduce-kv (fn [acc k v]
                          `(.. ,acc " " ,(f k v)))
                        group opts)]
    `(->> ,args
          (string.format "hi %s")
          vim.cmd)))

(fn t [key]
  "Returns the string with termcodes replaced"
  `(vim.api.nvim_replace_termcodes ,(->str key) true true true))

(fn feedkeys [key]
  `(vim.api.nvim_feedkeys ,(t key) :n true))

(fn has? [property]
  "Returns true if vim has a propety"
  `(match (vim.fn.has ,property)
     1 true
     0 false
     _# nil))

{: pug
 : vlua
 : set!
 : set-local!
 : let!
 : command!
 : buf-command!
 : lua-command!
 : lua-buf-command!
 : augroup!
 : buf-augroup!
 : autocmd!
 : buf-autocmd!
 : nmap!
 : noremap!
 : buf-nmap!
 : buf-noremap!
 : hi!
 : t
 : feedkeys
 : has?
 : unless}
	;;;; Helper Functions Declaration
	;; (import-macros {: defn
	;; : into
	;; : empty
	;; : when-let
	;; : if-let
	;; : when-some
	;; : if-some} :cljlib.macros)

	(local {: inc
	: dec
	: first
	: last
	: rest
	: any?
	: every?
	:some some?
	: keys
	: vals
	: reduce
	: reduce-kv
	: merge
	:mapv map
	: filter
	: string?
	: number?
	: nil?
	: contains?
	;; :map? tbl?
	;; : set?
	;; :vector? seq?
	;; : vector
	: empty?
	: cons
	: conj
	: dissoc} (require :cljlib))

	;; (local {: format} string)

	;; Reserve name for `into` macros
	;; tbl->seq
	;; seq->tbl
	;; str->seq

	(fn ->str [obj]
	"Converts an object to its string representation"
	(tostring obj))

	(fn str->seq [s]
	"Convert an string into a sequence of characters."
	(icollect [c (string.gmatch s ".")]
	c))

	;; (fn ->key-opts [seq]
	;; "Returns a set following the structure of `{:key true}` from a sequence"
	;; (reduce #(merge $1 {$2 true}) {} seq))

	(fn ->key-opts [xs]
	"Convert a sequence into a table of each value of the sequence as the
	key and the value being `true`."
	(collect [_ v (ipairs xs)]
	(values v true)))

	(fn fn? [obj]
	"Returns true if the object is a function
	This only works at compilation time"
	(and (list? obj) (or (= (->str (first obj)) :hashfn)
	(= (->str (first obj)) :fn))))

	(fn exists? [module-name]
	"Returns true if the module exists and false if it doesn't"
	(let [(ok? _) (pcall require module-name)]
	ok?))

	;;; Macros Declaration

	;; NOTE: https://github.com/rktjmp/hotpot.nvim/discussions/6
	;; Put Unique Global
	;;
	;; (val :any prefix? :string) -> (uuid :string)
	;;
	;; Takes any given value, generates a unique name (with optional prefix)
	;; and inserts value into _G. Returns unique name.
	(fn pug [val prefix?]
	;; gensym will generate a unique id across a compile pass, but hotpot/aniseed
	;; may compile files in separate passes as they are modified, so symbols may
	;; collide you can avoid this by passing a unique prefix per-file or using
	;; something like the "uid" below, based on compile time
	(let [inter-compile-uid (_G.os.date "%s")
	name (if prefix?
	(.. (->str (gensym prefix?)) inter-compile-uid)
	(.. (->str (gensym :pug)) inter-compile-uid))]
	`(do
	(tset _G ,name ,val)
	,name)))

	;; Wrap given in v:lua x pug call
	(fn vlua [what prefix?]
	`(.. "v:lua." ,(pug what prefix?) "()"))

	;; BUG: `vlua` seems to have side-effect with `aniseed` plugin
	;; current version using gensym doesn't evaluate `vlua` at runtime
	(fn command! [name expr]
	(let [name (->str name)]
	(if (fn? expr)
	`(vim.cmd (string.format "command! %s call %s" ,name ,(vlua expr)))
	`(vim.cmd (string.format "command! %s %s" ,name ,expr)))))

	(fn buf-command! [name expr]
	(let [name (->str name)]
	(if (fn? expr)
	`(vim.cmd (string.format "command! -buffer %s call %s" ,name ,(vlua expr)))
	`(vim.cmd (string.format "command! -buffer %s %s" ,name ,expr)))))

	;; (fn command! [name f]
	;; `(vim.cmd ,(string.format "command! %s %s" (->str name) (->str f))))

	;; (fn buf-command! [name f]
	;; `(vim.cmd ,(string.format "command! -buffer %s %s" (->str name) (->str f))))

	(fn lua-command! [name f]
	(let [f (.. "lua " (->str f))]
	`(command! ,name ,f)))

	(fn lua-buf-command! [name f]
	(let [f (.. "lua " (->str f))]
	`(buf-command! ,name ,f)))

	(fn unless [condition ...]
	"Takes a single condition and evaluates the rest as a body if it's nil or
	false. This is intended for side-effects."
	`(when (not ,condition)
	,...))

	(fn set! [...]
	"Set one or multiple vim options using the `vim.opt` API
	The option name must be a symbol
	If the option doesn't have a corresponding value, if it begins with no the
	value becomes false, and if it doesn't it becomes true"
	(fn expr [name ?value]
	(let [name (->str name)
	value (if (nil? ?value) (not (name:match :^no)) ?value)
	name (if (nil? ?value) (or (name:match "^no(.*)$") name) name)]
	(if (fn? value)
	`(tset vim.opt ,name (string.format "%s" ,(vlua value)))
	(match (name:sub -1)
	"+" `(: (. vim.opt ,(name:sub 1 -2)) :append ,value)
	"-" `(: (. vim.opt ,(name:sub 1 -2)) :remove ,value)
	"^" `(: (. vim.opt ,(name:sub 1 -2)) :prepend ,value)
	_ `(tset vim.opt ,name ,value)))))

	(fn exprs [...]
	(match [...]
	(where [& rest] (empty? rest)) []
	(where [name value & rest] (not (sym? value)))
	[(expr name value) (unpack (exprs (unpack rest)))]
	[name & rest] [(expr name) (unpack (exprs (unpack rest)))]
	_ []))

	(let [exprs (exprs ...)]
	(if (> (length exprs) 1)
	`(do
	,(unpack exprs))
	(unpack exprs))))

	(fn set-local! [...]
	"Set a local vim option using the `vim.opt_local` API"
	(fn expr [name ?value]
	(let [name (->str name)
	value (if (nil? ?value) (not (name:match :^no)) ?value)
	name (if (nil? ?value) (or (name:match "^no(.*)$") name) name)]
	(if (fn? value)
	`(tset vim.opt_local ,name (string.format "%s" ,(vlua value)))
	(match (name:sub -1)
	"+" `(: (. vim.opt_local ,(name:sub 1 -2)) :append ,value)
	"-" `(: (. vim.opt_local ,(name:sub 1 -2)) :remove ,value)
	"^" `(: (. vim.opt_local ,(name:sub 1 -2)) :prepend ,value)
	_ `(tset vim.opt_local ,name ,value)))))

	(fn exprs [...]
	(match [...]
	(where [& rest] (empty? rest)) []
	(where [name value & rest] (not (sym? value)))
	[(expr name value) (unpack (exprs (unpack rest)))]
	[name & rest] [(expr name) (unpack (exprs (unpack rest)))]
	_ []))

	(let [exprs (exprs ...)]
	(if (> (length exprs) 1)
	`(do
	,(unpack exprs))
	(unpack exprs))))

	(fn let! [...]
	"Set a vim variable using the vim.[g b w t] API"
	(fn expr [name value]
	(let [name (->str name)
	scope (when (contains? [:g/ :b/ :w/ :t/] (name:sub 1 2))
	(name:sub 1 1))
	name (if (nil? scope) name (name:sub 3))]
	`(tset ,(match scope
	:b `vim.b
	:w `vim.w
	:t `vim.t
	_ `vim.g) ,name ,value)))

	(fn exprs [...]
	(match [...]
	(where [& rest] (empty? rest)) []
	[name value & rest] [(expr name value) (unpack (exprs (unpack rest)))]
	_ []))

	(let [exprs (exprs ...)]
	(if (> (length exprs) 1)
	`(do
	,(unpack exprs))
	(unpack exprs))))

	(fn augroup! [name ...]
	"Defines an autocommand group using the `vim.cmd` API."
	`(do
	,(unpack
	(-> [`(vim.cmd ,(string.format "augroup %s" name))
	`(vim.cmd "autocmd!")]
	(conj ...)
	(conj `(vim.cmd "augroup END"))))))

	(fn buf-augroup! [name ...]
	"Defines a buffer-local autocommand group using the `vim.cmd` API."
	`(do
	,(unpack
	(-> [`(vim.cmd ,(string.format "augroup %s" name))
	`(vim.cmd "autocmd! * <buffer>")]
	(conj ...)
	(conj `(vim.cmd "augroup END"))))))

	(fn autocmd! [events pattern command]
	"Defines an autocommand"
	(let [events (if (sequence? events) events [events])
	events (-> (map ->str events)
	(table.concat ","))
	pattern (if (sequence? pattern) pattern [pattern])
	pattern (-> (map ->str pattern)
	(table.concat ","))]
	(if (fn? command)
	`(vim.cmd (string.format "autocmd %s %s call %s" ,events ,pattern
	,(vlua command)))
	`(vim.cmd (string.format "autocmd %s %s %s" ,events ,pattern ,command)))))

	(fn buf-autocmd! [events command]
	"Defines an autocommand"
	(let [events (if (sequence? events) events [events])
	events (-> (map ->str events)
	(table.concat ","))]
	(if (fn? command)
	`(vim.cmd (string.format "autocmd %s <buffer> call %s" ,events
	,(vlua command)))
	`(vim.cmd (string.format "autocmd %s <buffer> %s" ,events ,command)))))

	(fn wk-map! [mode
	lhs
	{:buffer buffer?
	:silent silent?
	:noremap noremap?
	:nowait nowait?}
	description]
	"A mapping using which-key"
	`(let [(ok?# which-key#) (pcall require :which-key)]
	(when ok?#
	(which-key#.register {,lhs ,description}
	{:mode ,mode
	:buffer ,(if buffer? 0)
	:silent ,(if silent? true)
	:noremap ,(if (not noremap?) false)
	:nowait ,(if nowait? true)}))))

	(fn nmap! [[modes & options] lhs rhs ?description]
	"Defines a vim mapping using the `vim.api.nvim_set_keymap` API or the
	`vim.api.nvim_buf_set_keymap` if the option `:buffer` was passed.
	Support all the options the API supports.
	If the `rhs` argument is a function then automatically includes the `:expr`
	option."
	(fn nvim-set-keymap [mode lhs rhs options]
	(let [buffer? (?. options :buffer)
	options (dissoc options :buffer)]
	(if buffer?
	`(vim.api.nvim_buf_set_keymap 0 ,mode ,lhs ,rhs ,options)
	`(vim.api.nvim_set_keymap ,mode ,lhs ,rhs ,options))))

	(fn is-rhs-a-fn? [rhs]
	(if (fn? rhs)
	(vlua rhs)
	rhs))

	(let [modes (-> modes
	->str
	str->seq)
	options
	(if (fn? rhs)
	(conj options :expr)
	options)
	options (->key-opts options)
	exprs (map #(nvim-set-keymap $ lhs (is-rhs-a-fn? rhs) options) modes)
	exprs (if (and ?description (exists? :which-key))
	(conj exprs (unpack (map #(wk-map! $ lhs options ?description) modes)))
	exprs)]
	(if (> (length exprs) 1)
	`(do
	,(unpack exprs))
	(unpack exprs))))

	(fn noremap! [[modes & options] lhs rhs ?description]
	"Defines a vim mapping using the `vim.api.nvim_set_keymap` API or the
	`vim.api.nvim_buf_set_keymap` if the option `:buffer` was passed.
	Support all the options the API supports.
	If the `rhs` argument is a function then automatically includes the `:expr`
	option.
	Automatically includes the `:noremap` option."
	(let [options (cons :noremap options)]
	`(nmap! ,(cons modes options) ,lhs ,rhs ,?description)))

	(fn buf-nmap! [[modes & options] lhs rhs ?description]
	"Defines a vim mapping using the `vim.api.nvim_buf_set_keymap` if the option
	`:buffer` was passed.
	Support all the options the API supports.
	If the `rhs` argument is a function then automatically includes the `:expr`
	option."
	(let [options (cons :buffer options)]
	`(nmap! ,(cons modes options) ,lhs ,rhs ,?description)))

	(fn buf-noremap! [[modes & options] lhs rhs ?description]
	"Defines a vim mapping using the `vim.api.nvim_buf_set_keymap` if the option
	`:buffer` was passed.
	Support all the options the API supports.
	If the `rhs` argument is a function then automatically includes the `:expr`
	option.
	Automatically includes the `:noremap` option."
	(let [options (->> options
	(cons :buffer)
	(cons :noremap))]
	`(nmap! ,(cons modes options) ,lhs ,rhs ,?description)))

	(fn hi! [group opts]
	"Defines a highlight"
	(let [f (fn [k v]
	(match k
	:fg (let [fg (. opts :fg)]
	`(.. :ctermfg= ,fg " guifg=" ,fg))
	:bg (let [bg (. opts :bg)]
	`(.. :ctermbg= ,bg " guibg=" ,bg))
	_ `(.. ,(->str k) "=" ,v)))
	args (reduce-kv (fn [acc k v]
	`(.. ,acc " " ,(f k v)))
	group opts)]
	`(->> ,args
	(string.format "hi %s")
	vim.cmd)))

	(fn t [key]
	"Returns the string with termcodes replaced"
	`(vim.api.nvim_replace_termcodes ,(->str key) true true true))

	(fn feedkeys [key]
	`(vim.api.nvim_feedkeys ,(t key) :n true))

	(fn has? [property]
	"Returns true if vim has a propety"
	`(match (vim.fn.has ,property)
	1 true
	0 false
	_# nil))

	{: pug
	: vlua
	: set!
	: set-local!
	: let!
	: command!
	: buf-command!
	: lua-command!
	: lua-buf-command!
	: augroup!
	: buf-augroup!
	: autocmd!
	: buf-autocmd!
	: nmap!
	: noremap!
	: buf-nmap!
	: buf-noremap!
	: hi!
	: t
	: feedkeys
	: has?
	: unless}