s/gen_uint/generate_uint/g, per review comments

extras/random/binfile.m

@@ -43,10 +43,10 @@
     %
     % Throws an exception if the end-of-file is reached.
     %
-:- pred gen_uint8(binfile::in, uint8::out, io::di, io::uo) is det.
-:- pred gen_uint16(binfile::in, uint16::out, io::di, io::uo) is det.
-:- pred gen_uint32(binfile::in, uint32::out, io::di, io::uo) is det.
-:- pred gen_uint64(binfile::in, uint64::out, io::di, io::uo) is det.
+:- pred generate_uint8(binfile::in, uint8::out, io::di, io::uo) is det.
+:- pred generate_uint16(binfile::in, uint16::out, io::di, io::uo) is det.
+:- pred generate_uint32(binfile::in, uint32::out, io::di, io::uo) is det.
+:- pred generate_uint64(binfile::in, uint64::out, io::di, io::uo) is det.
 
 %---------------------------------------------------------------------------%
 
@@ -61,10 +61,10 @@
     --->    binfile(binary_input_stream).
 
 :- instance urandom(binfile, io) where [
-    pred(gen_uint8/4) is binfile.gen_uint8,
-    pred(gen_uint16/4) is binfile.gen_uint16,
-    pred(gen_uint32/4) is binfile.gen_uint32,
-    pred(gen_uint64/4) is binfile.gen_uint64
+    pred(generate_uint8/4) is binfile.generate_uint8,
+    pred(generate_uint16/4) is binfile.generate_uint16,
+    pred(generate_uint32/4) is binfile.generate_uint32,
+    pred(generate_uint64/4) is binfile.generate_uint64
 ].
 
 %---------------------------------------------------------------------------%
@@ -84,7 +84,7 @@
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(binfile(Stream), N, !IO) :-
+generate_uint8(binfile(Stream), N, !IO) :-
     io.read_binary_uint8(Stream, Res, !IO),
     (
         Res = ok(N)
@@ -96,15 +96,15 @@
         unexpected($pred, io.error_message(E))
     ).
 
-gen_uint16(binfile(Stream), N, !IO) :-
+generate_uint16(binfile(Stream), N, !IO) :-
     io.read_binary_uint16_be(Stream, Res, !IO),
     handle_res(Res, N).
 
-gen_uint32(binfile(Stream), N, !IO) :-
+generate_uint32(binfile(Stream), N, !IO) :-
     io.read_binary_uint32_be(Stream, Res, !IO),
     handle_res(Res, N).
 
-gen_uint64(binfile(Stream), N, !IO) :-
+generate_uint64(binfile(Stream), N, !IO) :-
     io.read_binary_uint64_be(Stream, Res, !IO),
     handle_res(Res, N).
 

extras/random/marsaglia.m

@@ -39,10 +39,10 @@
     % Generate a uniformly distributed pseudo-random unsigned integer
     % of 8, 16, 32 or 64 bytes, respectively.
     %
-:- pred gen_uint8(uint8::out, random::in, random::out) is det.
-:- pred gen_uint16(uint16::out, random::in, random::out) is det.
-:- pred gen_uint32(uint32::out, random::in, random::out) is det.
-:- pred gen_uint64(uint64::out, random::in, random::out) is det.
+:- pred generate_uint8(uint8::out, random::in, random::out) is det.
+:- pred generate_uint16(uint16::out, random::in, random::out) is det.
+:- pred generate_uint32(uint32::out, random::in, random::out) is det.
+:- pred generate_uint64(uint64::out, random::in, random::out) is det.
 
 %---------------------------------------------------------------------------%
 
@@ -59,10 +59,10 @@
     --->    random(uint64).
 
 :- instance random(random) where [
-    pred(gen_uint8/3) is marsaglia.gen_uint8,
-    pred(gen_uint16/3) is marsaglia.gen_uint16,
-    pred(gen_uint32/3) is marsaglia.gen_uint32,
-    pred(gen_uint64/3) is marsaglia.gen_uint64
+    pred(generate_uint8/3) is marsaglia.generate_uint8,
+    pred(generate_uint16/3) is marsaglia.generate_uint16,
+    pred(generate_uint32/3) is marsaglia.generate_uint32,
+    pred(generate_uint64/3) is marsaglia.generate_uint64
 ].
 
 init = seed(0u32, 0u32).
@@ -74,26 +74,26 @@
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(N, !R) :-
-    marsaglia.gen_uint32(N0, !R),
+generate_uint8(N, !R) :-
+    marsaglia.generate_uint32(N0, !R),
     N1 = uint32.cast_to_int(N0 >> 24),
     N = uint8.cast_from_int(N1).
 
-gen_uint16(N, !R) :-
-    marsaglia.gen_uint32(N0, !R),
+generate_uint16(N, !R) :-
+    marsaglia.generate_uint32(N0, !R),
     N1 = uint32.cast_to_int(N0 >> 16),
     N = uint16.cast_from_int(N1).
 
-gen_uint64(N, !R) :-
-    marsaglia.gen_uint32(A0, !R),
-    marsaglia.gen_uint32(B0, !R),
+generate_uint64(N, !R) :-
+    marsaglia.generate_uint32(A0, !R),
+    marsaglia.generate_uint32(B0, !R),
     A = uint32.cast_to_uint64(A0),
     B = uint32.cast_to_uint64(B0),
     N = A + (B << 32).
 
 %---------------------------------------------------------------------------%
 
-gen_uint32(N, R0, R) :-
+generate_uint32(N, R0, R) :-
     R0 = random(S0),
     unpack_uint64(S0, SX0, SY0),
     A = 18000u32,

extras/random/tausworthe.m

@@ -67,10 +67,10 @@
     % Throws an exception if the params and ustate are not the same size
     % (i.e., both 3-combo or both 4-combo).
     %
-:- pred gen_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
-:- pred gen_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint8(params::in, uint8::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint16(params::in, uint16::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint32(params::in, uint32::out, ustate::di, ustate::uo) is det.
+:- pred generate_uint64(params::in, uint64::out, ustate::di, ustate::uo) is det.
 
     % Duplicate a tausworthe RNG state.
     %
@@ -105,10 +105,10 @@
             ).
 
 :- instance urandom(params, ustate) where [
-    pred(gen_uint8/4) is tausworthe.gen_uint8,
-    pred(gen_uint16/4) is tausworthe.gen_uint16,
-    pred(gen_uint32/4) is tausworthe.gen_uint32,
-    pred(gen_uint64/4) is tausworthe.gen_uint64
+    pred(generate_uint8/4) is tausworthe.generate_uint8,
+    pred(generate_uint16/4) is tausworthe.generate_uint16,
+    pred(generate_uint32/4) is tausworthe.generate_uint32,
+    pred(generate_uint64/4) is tausworthe.generate_uint64
 ].
 
 :- instance urandom_dup(ustate) where [
@@ -123,26 +123,26 @@
 
 %---------------------------------------------------------------------------%
 
-gen_uint8(RP, N, !RS) :-
-    tausworthe.gen_uint32(RP, N0, !RS),
+generate_uint8(RP, N, !RS) :-
+    tausworthe.generate_uint32(RP, N0, !RS),
     N1 = uint32.cast_to_int(N0 >> 24),
     N = uint8.cast_from_int(N1).
 
-gen_uint16(RP, N, !RS) :-
-    tausworthe.gen_uint32(RP, N0, !RS),
+generate_uint16(RP, N, !RS) :-
+    tausworthe.generate_uint32(RP, N0, !RS),
     N1 = uint32.cast_to_int(N0 >> 16),
     N = uint16.cast_from_int(N1).
 
-gen_uint64(RP, N, !RS) :-
-    tausworthe.gen_uint32(RP, A0, !RS),
-    tausworthe.gen_uint32(RP, B0, !RS),
+generate_uint64(RP, N, !RS) :-
+    tausworthe.generate_uint32(RP, A0, !RS),
+    tausworthe.generate_uint32(RP, B0, !RS),
     A = uint32.cast_to_uint64(A0),
     B = uint32.cast_to_uint64(B0),
     N = A + (B << 32).
 
 %---------------------------------------------------------------------------%
 
-gen_uint32(RP, N, RS0, RS) :-
+generate_uint32(RP, N, RS0, RS) :-
     RS0 = ustate(Seed0),
     Size = array.size(Seed0),
     rand(RP, 0, Size, 0u32, N, Seed0, Seed),
@@ -182,7 +182,7 @@
     seed_2(0, Size, Ks, Ps, Ds, Shft0, Shft, Mask0, Mask, Seed0, Seed),
     RP = params(Qs, Ps, Shft, Mask),
     RS0 = unsafe_promise_unique(ustate(Seed)),
-    tausworthe.gen_uint32(RP, _, RS0, RS).
+    tausworthe.generate_uint32(RP, _, RS0, RS).
 
 :- pred seed_2(int::in, int::in, array(int)::in, array(int)::in,
     array(uint32)::in, array(int)::array_di, array(int)::array_uo,