• Rust

Uniform::new_inclusive(a, b).sample(&mut rand::thread_rng())

• Rust

fn pick(a: i32, b: i32) -> i32 {
    let between = Range::new(a, b);
    let mut rng = rand::thread_rng();
    between.ind_sample(&mut rng)
}

• Ada

declare
   subtype Random_Range is Integer range A .. B;
   package Rand is
      new Ada.Numerics.Discrete_Random (Random_Range);
   use Rand;
   Gen    : Generator;
   Result : Random_Range;
begin
   Reset (Gen);
   Result := Random (Gen);
end;

• C

int pick(int a, int b)
{
	int upper_bound = b - a + 1;
	int max = RAND_MAX - RAND_MAX % upper_bound;
	int r;

	do {
		r = rand();
	} while (r >= max);
	r = r % upper_bound;
	return a + r;
}

• Clojure

(+ a (rand-int (- b a)))

• C++

std::mt19937 gen;
std::uniform_int_distribution<size_t> uid (a, b);
uid (gen);

• C#

Random.Shared.Next(a, b + 1)

• C#

Random r = new Random();
return r.Next(a, b + 1);

• D

auto x1 = uniform(a, b+1);
auto x2 = uniform!"[]"(a, b);

• Dart

int pick(int a, int b) => a + Random().nextInt(b - a + 1);

• Elixir

a - 1 + :rand.uniform(b-a+1)

• Elixir

:crypto.rand_uniform(a, b)

• Erlang

crypto:rand_uniform(A, B)

• Fortran

real :: c
integer :: res

call random_number(c)
res = int((b-a+1)*c)

• Go

func pick(a,b int) int {
	return a + rand.Intn(b-a+1)
}

• Go

func pick(a, b int) int {
	return a + rand.IntN(b-a+1)
}

• Haskell

let pick (a, b) = randomRIO (a, b) :: IO Integer
 in pick (1, 6) >>= print

• JS

function pick(a, b) {
    return a + Math.floor(Math.random() * (b - a + 1));
}

• Java

int pick(int a, int b){
	return a + new Random().nextInt(b - a + 1);
}

• Java

int v = new Random().nextInt(a, b + 1);

• Kotlin

fun pick(a: Int, b: Int): Int {
    return (a..b).random()
}

• Lisp

(defun r (a  b)
(+ a (random (+ 1 (- b a )))))

• Lua

math.random(a, b)

• Obj-C

a+arc4random_uniform(b+1)

• PHP

rand($a, $b)

• Pascal

var
  _a, _b, _r: Integer;
begin
  _r := RandomRange(_a, _b);
end; 

• Perl

my ($min, $max) = (5, 25);
my $val = $min + int(rand($max-$min));

• Python

random.randint(a,b)

• Ruby

rand(a..b)

• Scala

a + Random.nextInt(b + 1)

• Scheme

(floor (+ a (* (add1 (- b a)) (random 1.0))))

• Scheme

(+ a (random (add1 (- b a))))

• Smalltalk

(a to: b) atRandom