How do I type a single opening bracket without trigering auto-pair in Helix?

[mantzu132]

In Neovim you can do C+v, this enters literal input mode. Then you can type in the opening bracket [, (, { and so on and it won't add the closing bracket.

This is really useful for auto-pairs. Can you do something like that in Helix?

[waddie]

You could bind macros to set the option off and on, like:

[keys.insert]
C-v = "@<esc>:set auto-pairs false<ret>i"
C-V = "@<esc>:set auto-pairs true<ret>i"

Not as convenient as Vim because you need a different key instead of a toggle, but it will do the job.

Adding a toggle function for a single binding will be trivial with the plugin system, for what it’s worth.

EDIT, with Steel for adventurous Schemers:

(require "helix/configuration.scm")
(require "helix/keymaps.scm")
(require "helix/misc.scm")

;;@doc
;; Toggle the auto-pairs setting on/off.
(define (toggle-auto-pairs)
  (let ((new-state (if (get-config-option-value "auto-pairs") #f #t)))
    (auto-pairs new-state)
    (set-status! (string-append "auto-pairs: " (if new-state "on" "off")))))

(keymap (global)
  (normal (C-v ":toggle-auto-pairs"))
  (select (C-v ":toggle-auto-pairs"))
  (insert (C-v ":toggle-auto-pairs")))

[mantzu132]

Does work.

However, it's not as convenient as in Vim not only because you need a different key, but you also need to press this 2 times (off -> type char -> on). This is almost the same as typing the char -> moving to the end of the closing bracket -> deleting it.

While as in Vim it's C+v -> type char and you're good to go.

These little things do add up. I feel this should be a core feature of auto-pairs and you shouldn't be expected to add these keybindings. After all, it's an universal problem if you're using them.

[waddie]

Gotcha. But say everyone agrees we should add NeoVim’s insert literal. Having now gone away and read up on what it actually does, while it’s not as trivial as toggling an option, it’s still a short function, even in Steel instead of native:

(require (prefix-in helix.static. "helix/static.scm"))
(require "helix/keymaps.scm")
(require "helix/misc.scm")
(require-builtin helix/components as helix.components.)

;;@doc
;; Insert the next keypress literally, bypassing auto-pairs, etc.
(define (literal-insert)
  (on-key-callback
    (lambda (event)
      (let* ((is? (lambda (spec) (equal? event (helix.components.string->key-event spec))))
             (insert-byte (lambda (n) (helix.static.insert_string (string (integer->char n)))))
             (ch (helix.components.on-key-event-char event))
             (letter (and ch
                      (let* ((lc (char-downcase ch))
                             (code (char->integer lc)))
                        (and (>= code 97) (<= code 122) lc)))))
        (cond
          ((is? "esc") (insert-byte 27))
          ((is? "ret") (insert-byte 13))
          ((is? "tab") (insert-byte 9))
          ((and letter (is? (string-append "C-" (string letter))))
            (insert-byte (- (char->integer letter) 96)))
          (ch (helix.static.insert_string (string ch)))
          (else (void)))))))

(keymap (global)
  (insert (C-v ":literal-insert")))

But using this highlights that it’s more complex than it appears: Helix currently has no way to render most of the literals Vim’s insert literal can be used to insert. So, if this was core functionality, is it dependent on adding support for displaying those invisible literals? Do we leave as-is and set many users up for confusion? Or do we add a limited version of the functionality now and come back to it later?

That’s starting to sound like the next 3 year death march. Maybe we just want to suppress auto-pairing instead, and insert literal being the NeoVim answer was a red herring. More complex again because now we need to resolve the auto-pairs first, but still a fairly small bit of code:

(require (prefix-in helix.static. "helix/static.scm"))
(require "helix/misc.scm")
(require "helix/configuration.scm")
(require-builtin helix/components as helix.components.)

;;@doc
;; Return the list of current auto-pairing characters.
(define (current-pair-chars)
  (let ((default-pair-chars (list #\( #\) #\{ #\} #\[ #\] #\' #\" #\`))
        (cfg (get-config-option-value "auto-pairs")))
    (cond
      ((equal? cfg #t) default-pair-chars)
      ((equal? cfg #f) '())
      ((hash? cfg) (map (lambda (x) (if (char? x) x (string-ref x 0)))
                    (append (hash-keys->list cfg) (hash-values->list cfg))))
      (else default-pair-chars))))

;;@doc
;; Insert the next keypress, but if it is one of the currently auto-paired
;; characters, insert it raw so no matching pair is added. Any other key is
;; typed normally.
(define (insert-without-pairing)
  (on-key-callback
    (lambda (event)
      (let ((ch (helix.components.on-key-event-char event)))
        (cond
          ((and ch (member ch (current-pair-chars)))
            (helix.static.insert_string (string ch)))
          (ch (helix.static.insert_char ch))
          (else (void)))))))

(keymap (global)
  (insert (C-v ":insert-without-pairing")))

I think I’d argue a plugin is exactly the right place for it in the short term. There are four easy, drop-in solutions right here to meet most people’s requirements and we can get some feedback based on real world use, while the size and shape of any potential native solution percolates (and before throwing a couple more PRs on the heap to moulder away).