==== Ait Registers ====

THIS IS A PROPOSAL NONE OF THIS IS VALID AS OF AIT 1.13 OR 1.14-git.

The purpose of registers in ait are similar to that in GNU Emacs or
vim: you've got something you want to save and recall it quickly. To
accomplish this ait takes a more vim approach while keeping the
keybindings similar to GNU Emacs. The prefix is C-x r. This will then
prompt the user to input one of many single character options:
s, i, <space>, f, b, j, m, e, E, and k. The first difference between
ait and Emacs is that it's not all one keybinding. C-x r starts up
the register function which then prompts the user. It's very very
fast so the prompting can be ignore once you've gotten the hang of
it. It will first prompt "Register Function: ". Single character
press will then prompt "Register to Read: ", then another single
character press will do the function using that register.

Registers are single POSIX valid characters such as:
[a-z][A-Z][0-9] which gives you 62 registers to pick from.
Technically speaking, registers are simply files named that character
found in the supplied `-r register_dir`. If no register directory is
provided, none of the functions will work and you will be prompted
with an error. The reason for this is because I don't like random
crap filling up my file system (I only support the same-dir backups
for Emacs feature parity), don't want to force people to have to use
the same directory, and allows for different directories for
different applications. For example, if I have a few registers that
contain some common boilerplate for react such as:
const [] = useState();
- or -
useEffect(() => {

}, []);
Maybe stored in registers S and E respectively, why would I want
those same registers if I'm working in ClojureScript where we don't
even make useState or useEffect hooks? Being able to pick the
register directory is very handy. The second thing to explain is why
files and not memory. Keeping these as files is very handy because
you can set them once and use them forever. Since when using ait
you commonly close it often; unlike the very common Emacsen's "hasn't
closed Emacs in over a month," you'd lose all your registers every
time!

What to do if 62 is too few!? I'm glad you asked. You can save
register data in a plain file with any name and just read from it.
This is found by supplying the universal argument when prompted to
input the register name. The msgline will which to a find file prompt
and you can find your file that way using the normal conviences. Note
that you can't use a open command here -- but maybe in the future!
Also, find file will start at the register directory so if you have
your longer named registers there it'll be nice and quick provided
that you name them for speed and not for comprehension...


Supported Register Functions (C-x r)
- C-x r s <reg>
- C-x r i <reg>
- C-x r <SPC> <reg>
- [NS] C-x r f <reg>
  - save [f]ile name to register
- [NS] C-x r b <reg>
  - save [b]uffer name to register
- C-x r j <reg>
  - if <reg> contains a number ONLY, jump to that point
  - if <reg> contains a string, see if it's a file path
    and open that file
- [NS] C-x r m <reg>
  - save keyboard [m]acro to reg
- [NS] C-x r e <reg>
  - [e]xecute keyboard macro in reg
  - does _not_ override the current keyboard macro. To override,
    use C-x r o <reg>.
- [NS] C-x r k <reg>
  - take from [k]ill ring and save in reg
  - probably should take universal argument to select which king-ring
    item
- [NS] C-x r c
  - [c]ompose register functions
  - prompt: "Composing Register Functions:"
    - and you just supply everyting at once For example, if you
      had a code snippet saved in 'E' and a keyboard macro to place
      the cursor in the right place for that snippet in 'e' you could
      run: C-x r c sRee
      Take react's useEffect:
      useEffect(() => {

      }, []);
      The first thing I want to do after this is plopped in is go
      between the brackets and put some crap in there. So why not
      save it in a register and run it quick: esc ; ]
      The best part is that you can use that same keyboard macro
      with useState and useCallback as well:
      C-x r c sSee -or- C-x r c sCee
      for example.
      An alternative to doing it like this is to just do the entire
      thing in a keyboard macro. This is fine for small stuff but if
      you have large bit of text the keyboard macro can be a little
      slow since it requires repainting every time. I find it much
      quicker to have two that you combine.
- C-u on register name prompt to get find file


NS = Not Standard from GNU Emacs
