stdrandom 0.3.0-alpha.5

Generate random numbers using only Rust standard library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use super::*;


#[test]
fn test_if_closure_is_copy_trait() {
    let value = 0u64; // `u64` is Copy
    let rng_closure = || value + 1; // Does not capture any non-Copy values

    // Checking if the closure is Copy by trying to create multiple instances
    let _rng_closure_clone = rng_closure; // If Copy, this should work without explicit cloning
    let _rng_closure_second = rng_closure; // Should still work if Copy

    let returned_value: u64 = gen_range(0..=50000, rng_closure);
    assert_eq!(
        returned_value,
        1,
        "Expected gen_range to return 1, but got {} instead",
        returned_value
    );

    println!("Test successful. Closure is Copy-compatible.");
}

#[test]
fn test_if_closure_is_copy_trait2() {
    let mut value = 0u64; // `u64` is Copy
    let rng_closure = move || { value +=1; value }; 

    // Checking if the closure is Copy by trying to create multiple instances
    let _rng_closure_clone = rng_closure; // If Copy, this should work without explicit cloning
    let _rng_closure_second = rng_closure; // Should still work if Copy

    let returned_value: u64 = gen_range(0..=50000, rng_closure);
    assert_eq!(
        returned_value,
        1,
        "Expected gen_range to return 1, but got {} instead",
        returned_value
    );

    println!("Test successful. Closure is Copy-compatible.");
}

#[test]
fn test_if_closure_is_copy_trait3() {
    let mut value = 0u64; // `u64` is Copy
    let rng_closure = move || { value +=1; value }; 

    // Checking if the closure is Copy by trying to create multiple instances
    let _rng_closure_clone = rng_closure; // If Copy, this should work without explicit cloning
    let _rng_closure_second = rng_closure; // Should still work if Copy

    let mut mutable = rng_closure;
    assert_eq!( mutable(), 1);
    assert_eq!( mutable(), 2);
    mutable = _rng_closure_clone;
    assert_eq!( mutable(), 1);

    println!("Test successful. Closure is Copy-compatible.");
}

#[test]
fn test_closure_copy_trait_ro() {
    let value = 0u64; // `u64` is Copy
    let rng_closure = || value + 1; // Does NOT modify captured value

    let _clone1 = rng_closure; // If Copy, this works
    let _clone2 = rng_closure; // If Copy, this also works

    assert_eq!(_clone1(), 1);
    assert_eq!(_clone1(), 1);
    assert_eq!(_clone2(), 1); // Should be the same result

    println!("Closure is Copy-compatible.");
}

#[test]
fn test_closure_copy_trait_rw() {
    let mut value = 0u64; // `u64` is Copy
    let rng_closure = move || { value +=1; value }; 

    let mut _clone1 = rng_closure; // If Copy, this works
    let mut _clone2 = rng_closure; // If Copy, this also works

    assert_eq!(_clone1(), 1);
    assert_eq!(_clone1(), 2);
    assert_eq!(_clone2(), 1); // Should be the same result
    assert_eq!(_clone2(), 2); // Should be the same result
    assert_eq!(_clone1(), 3);

    println!("Closure is Copy-compatible.");
}

#[test]
fn test_if_closure_is_copy_compiletime() {
    fn takes_copy<F: Copy>(_: F) {}

    let value = 0u64; // `u64` is Copy
    let rng_closure = || value + 1; // Does not modify captured values

    takes_copy(rng_closure); // If this compiles, closure is Copy

    let _clone1 = rng_closure;
    let _clone2 = rng_closure;

    assert_eq!(_clone1(), 1);
    assert_eq!(_clone2(), 1);
    assert_eq!(rng_closure(), 1);

    println!("Closure is truly Copy-compatible.");
}

#[test]
fn test_if_closure_is_copy_compiletime_rw() {
    fn takes_copy<F: Copy>(_: F) {}

    let mut value = 0u64; // `u64` is Copy
    let rng_closure = move || { value +=1; value }; 

    takes_copy(rng_closure); // If this compiles, closure is Copy

    let mut _clone1 = rng_closure;
    let mut _clone2 = rng_closure;

    assert_eq!(_clone1(), 1);
    assert_eq!(_clone2(), 1);

    println!("Closure is truly Copy-compatible.");
}

#[test]
fn test_if_closure_is_copy_compiletime_retval_check() {
    fn takes_copy<F: Copy + FnMut() -> u64>(closure: F) -> u64 {
        let mut mutable_closure = closure;
        mutable_closure() // Executes the closure and returns its value
    }

    let mut value = 0u64; // `u64` is Copy
    let rng_closure = move || { value +=1; value }; 

    let result1 = takes_copy(rng_closure); // If this compiles, closure is Copy
    let result2 = takes_copy(rng_closure); // If this compiles, closure is Copy

    let mut _clone1 = rng_closure;
    let mut _clone2 = rng_closure;

    assert_eq!(_clone1(), 1);
    assert_eq!(_clone2(), 1);
    assert_eq!(result1, 1, "Expected takes_copy to return 1, but got {}", result1);
    assert_eq!(result2, 1, "Expected takes_copy to return 1, but got {}", result2);

    println!("Closure is truly Copy-compatible.");
}

#[test]
#[allow(non_snake_case)]
fn test_if_closure_is_copy_42_chatGPT() {
    fn takes_copy<F: Copy + FnMut() -> u64>(closure: F) -> (u64, u64) {
        let mut copy1 = closure;
        let mut copy2 = closure; // If closure is Copy, this works
        (copy1(), copy2())
    }

    let mut value = 41u64; // `u64` is Copy
    let rng_closure = move || { value +=1; value }; 

    let (result1, result2) = takes_copy(rng_closure);
    
    assert_eq!(result1, 42, "left value not ok");
    assert_eq!(result2, 42, "right value not ok");
    
    println!("Closure is truly Copy-compatible.");
}