map global user a '*%s' -docstring 'select all'

• * puts the content of the main selection in the search register /
• % selects the whole buffer
• s opens a prompt waiting for a regex which will be used to make sub-selections. If nothing is entered and the prompt is validated with , the content of the search register is used by default.

more here

def -params 1 extend-line-down %{
  exec "%arg{1}X"
}
def -params 1 extend-line-up %{
  exec "%arg{1}K"
  try %{
    exec -draft ';\n'
    exec X
  }
  exec ''
}
map global normal x ':extend-line-down %val{count}'
map global normal X ':extend-line-up %val{count}'

Also checkout the vertical-selection plugin

so when you want to select the word - you select it like a text-object, more here

def -hidden select-prev-word-part %{
  exec [A-Z][a-z]+|[A-Z]+|[a-z]+
}
def -hidden select-next-word-part %{
  exec /[A-Z][a-z]+|[A-Z]+|[a-z]+
}
def -hidden extend-prev-word-part %{
  exec [A-Z][a-z]+|[A-Z]+|[a-z]+
}
def -hidden extend-next-word-part %{
  exec ?[A-Z][a-z]+|[A-Z]+|[a-z]+
}
map global normal w :select-next-word-part
map global normal W :extend-next-word-part

See: https://github.com/delapouite/kakoune-hump

# foo_bar → fooBar
# foo-bar → fooBar
# foo bar → fooBar
def camelcase %{
  exec '`s[-_]d~w'
}

# fooBar → foo_bar
# foo-bar → foo_bar
# foo bar → foo_bar
def snakecase %{
  exec 's-|[a-z][A-Z];as[-\s]+c_w`'
}

# fooBar → foo-bar
# foo_bar → foo-bar
# foo bar → foo-bar
def kebabcase %{
  exec 's_|[a-z][A-Z];as[_\s]+c-w`'
}

See https://gitlab.com/FlyingWombat/case.kak

Pipe your selection into sort: |sort You can also deduplicate with the uniq command or reverse the letters of a word with rev using similar strategies.

To go from

foo
bar
qux

to

1foo
2bar
3qux

Make one selection per line (with for instance), enter insert mode with I to move cursors at the beginning of each line and insert the content of the index register with #.

First solution using the keep regex primitive :

.{10,}

Second solution using the $ primitive. In this particular case it's longer to type but it's more generic and powerful since you can construct predicates based on any value:

$[ ${#kak_selection} -gt 10 ]

Here we use a combination of the shell test command [ and the # operator in the var expansion.

The following snippet keeps only "even" selections. So if you have 6 selections, it only keeps selection 2, 4 and 6 :

$[ $((kak_main_reg_hash % 2)) -eq 0 ]

Here we use a combination of the shell test command [ and the (()) shell arithmetic command.

Design more complex filters by using small wrappers in python or lua: https://discuss.kakoune.com/t/filter-your-selections-more-easily/1296

def selection-hull %{
  eval -save-regs 'abc' %{
    exec '"aZ' '"bZ' '"az"cZ'
    eval -itersel %{ exec '"bu' }
    exec '"bz'
  }
}

• Selections-combinations: how to use and

• vertical-selection copy the current selection up and downwards to all lines matching the current selection.
• phantom-selection interactively iterate over the current selections one by one.
• select-view select the visible part of a buffer.
• auto-percent enhance some primitives with bigger selections