Why doesn't vimscript provide a random number generator?

Question

EDIT Since 8.1.2342, Vim introduced a rand() function as described by @Maxim Kim's answer. I'll keep the question here for historical reference.

---

I recently needed to generate a random number in vim and this question gave me all the solutions I needed.

But I still have a question: Why is there no built-in function to generate a random number?

I mean the vimscript language provides functions to work with numbers like round(), min(), the basic operators +-*/, so what explains that the absence of a rand() function?

For now I see 2 possible explanations but I wasn't able to validate any of them:

• Technical limitations: I know the bad reputation of this language but I don't see what would make it unable to generate a random number.

• "Ideological" limitation: The creator of vim script could have decided that the language being made to edit text, doesn't need to generate random numbers and this functionality shouldn't be available to the user. I'm not a Vim guru but I don't understand how including such a function would hurt anything or anyone.

Is there another reason that I couldn't figure out by myself? Could someone enlighten me on this?

Answer 1

Because the patches have been sitting in the TODO list for almost five years.

Don't forget, vimscript wasn't designed: it is only the ever-changing interim result of a slow evolutionary process. Hell, it didn't even have an actual name in the doc until "VimL" was discreetly slipped in a bit before 7.4.

Answer 2

Well, generating random numbers isn't really the task of a an editor, IMHO. And with Vim, "the Unix way" to do it is to rely on other tools, that do it ... better. E.g. you can:

• on *nix systems, read "/dev/urandom" or similar
• call a program that does it
• write a plugin in python, ruby, lua etc. - all languages with 'random' support.

Simple, non-security concerned random functionality can be provided directly with vimscript, though, by reading ... time microseconds values. Here's how it is implemented with the vim-randomtag plugin:

function! s:randnum(max) abort
  return str2nr(matchstr(reltimestr(reltime()), '\v\.@<=\d+')[1:]) % a:max
endfunction

P.S. I'm not saying that it won't be useful to have a function in vimscript, though ...

Answer 3

Vim has rand() function since 8.1.2342

rand([{expr}])                      *rand()* *random*
        Return a pseudo-random Number generated with an xoshiro128**
        algorithm using seed {expr}.  The returned number is 32 bits,
        also on 64 bits systems, for consistency.
        {expr} can be initialized by |srand()| and will be updated by
        rand().  If {expr} is omitted, an internal seed value is used
        and updated.

        Examples: >
            :echo rand()
            :let seed = srand()
            :echo rand(seed)
            :echo rand(seed) % 16  " random number 0 - 15

Answer 4

If you happen to use neovim, you can also use luaeval() to generate random numbers (this is for neovim only, does not work in Vim).

" math.randomseed() is need to make the random() function generate different numbers 
" on each use. Otherwise, the first number it generate seems same all the time.
luaeval('math.randomseed(os.time())')
let num = luaeval('math.random(1, 10)')

Based on my benchmark, the luaeval() code is about twice as fast as the code based on vim script.

Answer 5

As I try to provide portable plugins I have the following in my library plugin. I should be able to detect and use rand() now.

" Function: lh#common#rand(max) {{{2
" This function requires ruby, and it may move to another autoload plugin
if has('ruby')
  function! lh#common#rand_ruby(max)
    ruby << EOF
    rmax = VIM::evaluate("a:max")
    rmax = nil if rmax == ""
    VIM::command("return #{rand(rmax).inspect}")
EOF
  endfunction
  let s:random = get(s:, 'random', 'ruby')
endif

if !exists('s:random')
  " TODO: use pyx!
  let py_flavour = lh#python#best_still_avail()
  if !empty(py_flavour)
    function! lh#common#rand_python3(max)
python3 << EOF
import vim, random
rmax = eval(vim.eval("a:max")) - 1
# rmax = nil if rmax == ""
res = random.randint(0, rmax)
vim.command("return %d" % (res,))
EOF
    endfunction
    function! lh#common#rand_python(max)
python << EOF
import vim, random
rmax = eval(vim.eval("a:max")) - 1
# rmax = nil if rmax == ""
res = random.randint(0, rmax)
vim.command("return %d" % (res,))
EOF
    endfunction
    let s:random = get(s:, 'random', py_flavour)
  endif
endif

if lh#os#system_detected() == 'unix'
  " This flavour is very slow, and best avoided!
  function! lh#common#rand_unix(max)
    let nb_bytes = float2nr(log(a:max-1)/s:k_lg256)+1
    let rnd = matchstr(system('echo $RANDOM'), '\d\+')
    let res = rnd % a:max
    return res
  endfunction
  let s:random = get(s:, 'random', 'dev_unix')
endif

if lh#os#system_detected() == 'windows'
  " This flavour is very slow, and best avoided!
  function! lh#common#rand_unix(max)
    let nb_bytes = float2nr(log(a:max-1)/s:k_lg256)+1
    let rnd = matchstr(system('echo %RANDOM%'), '\d\+')
    let res = rnd % a:max
    return res
  endfunction
  let s:random = get(s:, 'random', 'dev_windows')
endif

if filereadable('/dev/urandom') && has('float')
  " This flavour is very slow!
  let s:k_lg256 = log(256)
  function! lh#common#rand_dev_urandom(max)
    let nb_bytes = float2nr(log(a:max-1)/s:k_lg256)+1
    let rnd = matchstr(system('od -A n -t d -N '.nb_bytes.' /dev/urandom'), '\d\+')
    let res = rnd % a:max
    return res
  endfunction
  let s:random = get(s:, 'random', 'dev_urandom')
endif

function! lh#common#rand(max)
  call lh#assert#value(s:).has_key('random')
  return lh#common#rand_{s:random}(a:max)
endfunction