rust #rustc 1.98.1 (48a229cea 2026-09-01)RL.SAwjL-df1bddb45adbe94b<%Z>64V`-2d2ab9fb0fe1def5 Generatorgenerate      reconstruct   set_indexreset_and_skip word_offsetremaining_results next_word&&& &next_u64_from_u32++++ + fill_bytes0 utils222next_u64_via_u3252fill_bytes_via_next_word777impl FnMut() -> Result2next_word_via_fill;;2 read_words>>> >  seedable_rngCCCC SeedableRngGSeedG from_seedG seed_from_u64Gfrom_rngKG try_from_rngMGforkGtry_forkCpcg32Q QMULQINC unwrap_errUUUUUZZErrorZ try_next_u32Z try_next_u64Ztry_fill_bytesU panic_msg`impl core::error::ErrorUbUd'rddreg'bwordiWordiiisealedmSealednBytesn from_le_bytesn to_le_bytesnn into_usizemt u t t tt m{ | { { {{ Rngnext_u32next_u64   CryptoRngTryRng TryCryptoRngRngCore TryRngCoreBlockRngresults> U UnwrapErr UU>UUUUU U  8 8 8 8888888 8!8"8#8$8%8*808085878;8>8K8M8O8P8Q8888888888]8^8_8_88888888888888888Gjn  FFچBg#g  ŦE" hjjnn Zbklt{yg#  h j n M L  4 Y " 3;X ,5( >MX b  T  d g9/4 T  gC, deU̖h dS ÜĜŜƜǜȜ_wĤĤŤ :M\, ggg cgbufcثq1ȡ dd DebugStructddd dd has_fieldsd19<De FL!$ D5E Lc  &J d!T! "!"l" r" " . " "T"" &""$"<"Լ" " "!!t   FFچB$\!$$!"\!""y"N8$%H F"v""""$ \% d%T%" %%% %"&ܐ&  &"  !" @ "<& 8& "L& #%>IFT" u k  W&3|& x" &&  &"'l'",'   ' "T&" &" &!<'$' Ԯ' $'  ř$% $' ř$%  ' ' $; !%&řǙșəʙ˙G*R{9 $d%$$$  "$%"Q"g",&"=":h - %("W":$$%$a ^l"""""" w"j/5()Y"($ $ * "|*" &"9%*T* s"gd*+ *E",* $,*""C""1L+ +"$T+ +"T]  [)$,l,",, , "|," &",&%,!+ + $L+",+[/""=Aoa"""3g"B40 0"$0L0 !"$$0 0" d0,1 1"L1$1 %1%D1 $D 5ܚ1p 03t~#1L16$1 1 d11"/ 05L0" 0c' $.QUe""67?36d3,3 "$$3<3T3 3" 3 "3",34#3w3J",31,3",3O":d7,7:$7<7d7%87 "L7 %(L>)7$7p7>-$71,7",7 %(%)Z:=$8d8,8:%<8,9T9 9"L9$9%9%D97?0ܪ9L9 9"9c,: 9  "  &" 9% ,: L:  :"$  '"K "̚:L:6$: x ::%889W" 85L8"L81,"9."mf""1.+qu,9a""":7G63$<d<,< 6<<,<  <" <"/  2"0"_ "l<= "  &"9 < L= ="$ '"K "= " &" 9 F = L= ="$ '"="<,> >" >"/ 2"0" _">" &" 9Fă>L>E>F>%D> ED5 ܳ> > "|>" &" 9F>l> ?"T? ?" ?6 "I ] ?6iI ] A>Q ] B? ] @AB @ !] C  ] E ř Argumentstemplateccg@#  ]]   ] [""C! ]>Q ]?Y ]EDE,KGKLK6$KG+F KK 2"A  0 B B DDEEEGHI ] ] HB5LA`$B"dB"LB1@  " "  Z  "  9 . "$D\TD` (= "S ] ( " _4E^] ^v ^^"TE _.+"..řǙșəʙ˙G*R{9 `^``DH\" I mmW5mm e6e>"We.)iiTi"".i"mi iq B"l"c~NeMatchvX]! ] řǙșəʙ˙G*R{9 j "#*dest3read_len@Cchunkssrczipped num_chunkss(dest_remA )< +left_val1 > right_val/ ?[ C":> wZ 7{Y*Z Z =K \+ \ ]H ^ _ ` b cy uE dee~f%eu'k 6e ,F`F`FF\Fd%lF#F4FeEDFF1|Ff,FBF+ FF 1 p F ` `dF`%`mqe"(chunk\sVw dFefeed t& %ÜĜŜƜǜȜ_w{3mLO.'[ÜĜŜƜǜȜ_w^f{b %ÜĜŜƜǜȜ_w{| dz t(z :    ,   mLO . )  [|} * L O)@9 < O YZ Ol  {  5 k?+29{ }  m[}OD^|8zmpf|n ezp|Hkrng 4 u  z>zO]}#zKz*O}6$td  "$ZE  \X* P^* "'*{A PU Q^ f ot  3, `L\ #/3)   24tc$ `+ %ÜĜŜƜǜȜ_w    x}  d m\ q  l, [ÜĜŜƜǜȜ_w}Ms %ÜĜŜƜǜȜ_w" ԡ4 oZJD1|f ,T+   t D wZ+ T, L \ ܇$3 '`- ʈB " . d mԖ \ / l. [  ,#  $d 4$%#D 'L &'X/ % "&l e#q%4" / |f"!+   4 3 a   L!) 7(&XZahd    d (l`l\T"I^^^řǙșəʙ˙G*R{9 `G ^Rp%`m[}OD^Ј p m "+`\&m 7Јn֕p $ mLme"m dstsxO  D      * Z _ f ܇chʈIWfS+܇ʈSuef~T%,iA"i ] A ]iI ]iI ] Q ]  ]  $l$" $". !] ] řj]] ]k !]Q]Y] P <$t%d%Y% d% wZ%A%%.t%D% w";T%%% QppIterMutp op]op\ohEC8G" ChunksExacto o\oIZ4%\%3% P^JJJJ by]R 3%  Q  % "m,%m&# &Қ-&&& d&4& &D&&#|&f<,&&&# "&&"9!&! &#  #/?#>3 ] ]$%29%$%4$m$qi"iii{""r! ]s5%<$"4%"y^..řǙșəʙ˙G*R{9  ptme<%l`"6ea spt tF 9s3 xr>"i"*kY|d 'Қf7e $$ %Q`>8i|"VD% % % H:$%l%4% Z/D%%!%ZE &"%L&H4&%"4&Y< KP \ ej  v  ,&  `T&&,& Q' $''t'c$ '&m&)|&f ,&< &#'t'D'& T'' T'','&#'L'X5' "l' Z"eL8'4|'f'''0$( (|( I=# ( ($/?JH%%,3& $%L%n\D%` 7^^^ؔp`Tm λλP l`&\Hmm%λee"{mseedx8  jZ@Pc"fmu5ǻfܼkD3 3 3.$3l343&D33T3 3I3$3 3|3ܼ9 3 32/?K33p$22v`,F<wWܼ D5  5  5.$6l646&D66!t66D676" D#/B$6   6|6ܼ 9  86[  %ÜĜŜƜǜȜ_wÜ! 6 6 Ü - 56 L T )5   M35yNU\6" 55 X`p:b, 3H ܼ^9t9 K$9'9O8`$8L8 ,t<< M$<'<P;ÜĜŜƜǜȜ_w;L; "4-L-QX0x5851_F42D_4C95_7F2DoTv0xA176_54E4_6FBE_17F3(  ( HM g^cRp   ( 8 .9aGr( ,4( .9AYc%/(', AFNH 6 CM( h2 B$/7 BS`j4dz*t(< _{} `{NL ]oÜĜŜƜǜȜ_w}ė Lzz4  d  0t  (<  _{}PL    ^oÜĜŜƜǜȜ_w}Ě L }4  t  0   -<  _{}WL    _ ÜĜŜƜǜȜ_w} L ` ÜĜŜƜǜȜ_w{Tsw|^: :"` (:     f 5>U Argumentf0m֔49d Z"+  g"+"  @`` ["`)  x`u| }T  ~ji" errn44 gs  ŦE" d h"4 ,"w_$λ,bytes3v $"xSλ\$ -ptD "T4 _TryFromIntError q:{ aDyQ$"ÜĜŜƜǜȜ_w"gA|D "$T4 _"NDzM",$ÜĜŜƜǜȜ_w"e"8Ԉ   , " ~ _$ Z",  <   $ "  S\ $  -pt D  " T  4  _ND   Q$ " ÜĜŜƜǜȜ_wf| D  "$ T  4 ED   M", $ 4{dz$t%D kTLp,tQzd$t&E kTLp,tQt$-L}L`p4%*U=L= "$=\==d= "Pt===fÜĜŜƜǜȜ_wĢ=L= >L>$>\>>d> Dt>>=fÜĜŜƜǜȜ_wĜ>L>?L?$?\??$t? D???>|ÜĜŜƜǜȜ_w?L?`?! +6=D2CUiDerefMutD" InfallibleT\G L #P#/,  _& # rand_core: core random number generation traits
[![crate][crate-badge]][crate-link] [![Docs][docs-image]][docs-link] [![Apache2/MIT licensed][license-image]][license-link] [![Build Status][build-image]][build-link]
This crate provides a collection of traits used by implementations of Random Number Generation (RNG) algorithms. Additionally, it includes helper utilities that assist with the implementation of these traits. Note that the traits focus solely on the core RNG functionality. Most users should prefer the [`rand`] crate, which offers more advanced RNG capabilities built on these core traits, such as sampling from restricted ranges, generating floating-point numbers, list permutations, and more. [`rand`]: https://docs.rs/rand ## License The crate is licensed under either of: * [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0) * [MIT license](http://opensource.org/licenses/MIT) at your option. [//]: # (badges) [crate-badge]: https://img.shields.io/crates/v/rand_core.svg [crate-link]: https://crates.io/crates/rand_core [docs-image]: https://docs.rs/rand_core/badge.svg [docs-link]: https://docs.rs/rand_core [license-image]: https://img.shields.io/badge/license-Apache2.0/MIT-blue.svg [build-image]: https://github.com/rust-random/rand_core/actions/workflows/test.yml/badge.svg?branch=master [license-link]: #license [build-link]: https://github.com/rust-random/rand_core/actions/workflows/test.yml?query=branch:master %https://www.rust-lang.org/favicon.ico9https://www.rust-lang.org/logos/rust-logo-128x128-blk.pngl2CUiKE";:G 9 Jl,) The [`Generator`] trait and [`BlockRng`]-1MJ Trait [`Generator`] may be implemented by block-generators; that is PRNGs<9 whose output is a *block* of words, such as `[u32; 16]`.NK The struct [`BlockRng`] wraps such a [`Generator`] together with an outputKH buffer and implements several methods (e.g. [`BlockRng::next_word`]) toLI assist in the implementation of [`TryRng`]. Note that (unlike in earlierNK versions of `rand_core`) [`BlockRng`] itself does not implement [`TryRng`]MJ since in practice we found it was always beneficial to use a wrapper type over [`BlockRng`].l # Example< ```" use core::convert::Infallible;.+ use rand_core::{Rng, SeedableRng, TryRng};0- use rand_core::block::{Generator, BlockRng}; struct MyRngCore { // Generator state ...̷ # state: [u32; 8],, }" impl Generator for MyRngCore { type Output = [u32; 8];;8 fn generate(&mut self, output: &mut Self::Output) {-* // Write a new block to output..." # *output = self.state;L },)& // Our RNG is a wrapper over BlockRng*' pub struct MyRng(BlockRng);   impl SeedableRng for MyRng {  type Seed = [u8; 32]; 0- fn from_seed(seed: Self::Seed) -> Self { " let core = MyRngCore {  // ... <9 # state: rand_core::utils::read_words(&seed),t }; &# MyRng(BlockRng::new(core))L ,    impl TryRng for MyRng {  type Error = Infallible;   #[inline] ?< fn try_next_u32(&mut self) -> Result { " Ok(self.0.next_word())L    ?< fn try_next_u64(&mut self) -> Result { *' Ok(self.0.next_u64_from_u32())LRO fn try_fill_bytes(&mut self, bytes: &mut [u8]) -> Result<(), Infallible> {(% Ok(self.0.fill_bytes(bytes))L,85 // And if applicable: impl TryCryptoRng for MyRng {}*' let mut rng = MyRng::seed_from_u64(0);0- println!("First value: {}", rng.next_u32());-* # assert_eq!(rng.next_u32(), 1171109249);< [`TryRng`]: crate::TryRng'$ [`SeedableRng`]: crate::SeedableRng, $j4c)L A random (block) generatorL! dѧ \ The output type._\ For use with [`rand_core::block`](crate::block) code this must be `[u32; _]` or `[u64; _]`.42%" Generate a new block of `output`.-* This must fill `output` with random data.D  B  $ 4- Destruct the output bufferEB This method is called on [`Drop`] of the [`Self::Output`] buffer.,) The default implementation does nothing.$  B  $  G   LgTg-/6  ggg cgcثq1ȡB   $' ƭL#$ B  $R $%| "t$ j"$"<$Ԁ " $  c "[]!" =: Create a new `BlockRng` from an existing RNG implementing 85 `Generator`. Results will be generated on first use.!$$B "$$D";8 Reconstruct from a core and a remaining-results buffer.##DA This may be used to deserialize using a `core` and the output of#  [`Self::remaining_results`].$$63 Returns `None` if `remaining_results` is too long.\$$ -,B % "$JW'H|(t( ($(ƱԠ(Ա ($ !"#$%@ ("@B*,* $"B *:$*+%L+ $"B +6$+/*,=: Re-generate buffer contents, skipping the first `n` words,-C@ Existing buffer contents are discarded. A new set of results is-GD generated (either immediately or when next required). The first `n`.IF words are skipped (this may be used to set a specific word position)..d. # Panics./GD This method will panic if `n >= N` where `N` is the buffer size (in\/ words).t/ $"B 0 ""$$03"1A> Get the number of words consumed since the start of the block22FC The result is in the range `0..N` where `N` is the buffer size (in\2\3 $"B 3 #"$$37'40- Access the unused part of the results buffer44FC The length of the returned slice is guaranteed to be less than the5EB length of `::Output` (i.e. less than `N` where5 `Output = [W; N]`).56=: This is a low-level interface intended for serialization.6'$ Results are not marked as consumed.7 $ -B 7 $"$$78 7'$ Generate the next word (e.g. `u32`)L8 $"B 8 %"$$8:A'('( EF:E :E:"t:Q* :"-/;*;)& Generate a `u64` from two `u32` words; QB& ;& *E$;@H,-.,-.|AtA A$AƱԚAԱ @$0  6 A"68A-|A Fill `dest`TA $ ZB+ A+ 0"$$BrE6tF011110`l)& Utilties to aid trait implementations*. ## PortabilityAENK For cross-platform reproducibility, Little-Endian order (least-significantJG part first) has been chosen as the standard for inter-type conversion.HE For example, [`next_u64_via_u32`] generates two `u32` values `x, y`,! then outputs `(y << 32) | x`.LI Byte-swapping (like the std `to_le` functions) is only needed to convertEB to/from byte sequences, and since its purpose is reproducibility,DA non-reproducible sources (e.g. `OsRng`) need not bother with it. ## Implementing [`TryRng`]KH Usually an implementation of [`TryRng`] will implement one of the threeLI methods over its internal source. The following helpers are provided for" the remaining implementations.ԍ **`fn try_next_u32`:**  - `self.next_u64() as u32`(% - `(self.next_u64() >> 32) as u32`1. - [next_word_via_fill][](self)Ԩ **`fn try_next_u64`:**/, - [next_u64_via_u32][](self)1 **`fn try_fill_bytes`:**=: - [fill_bytes_via_next_word][](self, dest)  # ## Implementing [`SeedableRng`]  KH In many cases, [`SeedableRng::Seed`] must be converted to `[u32; _]` or 41 `[u64; _]`. [`read_words`] may be used for this.  ' 30 [`SeedableRng::Seed`]: crate::SeedableRng::Seed t  ## Example  NK We demonstrate a simple multiplicative congruential generator (MCG), taken JG from M.E. O'Neill's blog post [Does It Beat the Minimal Standard?][0].  PM [0]: https://www.pcg-random.org/posts/does-it-beat-the-minimal-standard.html <  " 52 use rand_core::{Rng, SeedableRng, TryRng, utils};  pub struct Mcg128(u128);! impl SeedableRng for Mcg128 { type Seed = [u8; 16];0MJ // Always use little-endian byte order to ensure portable results+( Self(u128::from_le_bytes(seed))L, impl TryRng for Mcg128 { ?̞.+ Ok((self.next_u64() >> 32) as u32)L?MJ self.0 = self.0.wrapping_mul(0x0fc94e3bf4e9ab32866458cd56f5e605);%" Ok((self.0 >> 64) as u64)LPM fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Infallible> {HE utils::fill_bytes_via_next_word(dst, || self.try_next_u64())L,, #.+ # let mut rng = Mcg128::seed_from_u64(42);-* # assert_eq!(rng.next_u32(), 3443086493);63 # assert_eq!(rng.next_u64(), 3462997187007721903); # let mut buf = [0u8; 5]; # rng.fill_bytes(&mut buf);-* # assert_eq!(buf, [154, 23, 43, 68, 75]);<,57;> 423 $j4l$Q;8 Generate a `u64` using `next_u32`, little-endian order. }B66 44 5@ +( Fill `dst` with bytes using `next_word`A> This may be used to implement `fill_bytes` over `next_u32` orKH `next_u64`. Words are used in order of generation. The last word may be partially discarded.ĉ ZB89:89:   j$##Јd 7RIL{}wy Q52 Generate a `u32` or `u64` word using `fill_bytes`  ϞB<==< Ա  $ 4  ;"$P@B<>#@"-* Reads an array of words from a byte slice""GD Words are read from `src` in order, using LE conversion from bytes."d"##85 Panics if `size_of_val(src) != size_of::<[W; N]>()`.T# Z%B?@?@ $Ա #t#$# >"sfW(*- #"dGQ  CE 4CF,$&<9 A random number generator that can be explicitly seeded.X\EB This trait encapsulates the low-level functionality common to allGD pseudo-random number generators (PRNGs, or algorithmic generators).MJ A generator implementing `SeedableRng` will usually be deterministic, butNK beware that portability and reproducibility of results **is not implied**.OL Refer to documentation of the generator, noting that generators named afterIF a specific algorithm are usually tested for reproducibility against aKH reference vector, while `SmallRng` and `StdRng` specifically opt out of reproducibility guarantees.\GG,GHIJKMOPHIJKMOP7,<Z\Z\OD:- MKIOPJ6KH Seed type, which is restricted to types mutably-dereferenceable as `u8`1. arrays (we recommend `[u8; N]` for some `N`).KH It is recommended to seed PRNGs with a seed of at least circa 100 bits,LI which means an array of `[u8; 12]` or greater to avoid picking RNGs with" partially overlapping periods.JG For cryptographic RNG's a seed of 256 bits is recommended, `[u8; 32]`.:7 # Implementing `SeedableRng` for RNGs with large seeds  LI Note that [`Default`] is not implemented for large arrays `[u8; N]` with JG `N` > 32. To be able to implement the traits required by `SeedableRng` DA for RNGs with such large seeds, the newtype pattern can be used: <   use rand_core::SeedableRng;   const N: usize = 64;  #[derive(Clone)] &# pub struct MyRngSeed(pub [u8; N]);  # #[allow(dead_code)]  pub struct MyRng(MyRngSeed);   impl Default for MyRngSeed { # fn default() -> MyRngSeed {  MyRngSeed([0; N])L ,$! impl AsRef<[u8]> for MyRngSeed {# fn as_ref(&self) -> &[u8] { &self.0L,$! impl AsMut<[u8]> for MyRngSeed {+( fn as_mut(&mut self) -> &mut [u8] { &mut self.0L, К type Seed = MyRngSeed;0- fn from_seed(seed: MyRngSeed) -> MyRng { MyRng(seed)L,<$GG'+( Create a new PRNG using the given seed.HE PRNG implementations are allowed to assume that bits in the seed areHE well distributed. That means usually that the number of one and zeroMJ bits are roughly equal, and values like 0, 1 and (size - 1) are unlikely.HE Note that many non-cryptographic PRNGs will show poor quality outputKH if this is not adhered to. If you wish to seed from simple numbers, use `seed_from_u64` instead.KH All PRNG implementations should be reproducible unless otherwise noted:HE given a fixed `seed`, the same sequence of output should be producedLI on all runs, library versions and architectures (e.g. check endianness).KH Any "value-breaking" changes to the generator should require bumping at<9 least the minor version and documentation of the change.C@ It is not required that this function yield the same state as aLI reference implementation of the PRNG given equivalent seed; if necessary>; another constructor replicating behaviour from a reference  implementation can be added.JG PRNG implementations should make sure `from_seed` never panics. In theHE case that some special values (like an all zero seed) are not viableIF seeds it is preferable to map these to alternative constant value(s),KH for example `0xBAD5EEDu32` or `0x0DDB1A5E5BAD5EEDu64` ("odd biases? badLI seed"). This is assuming only a small number of values must be rejected.LBGGܼ$$()& Create a new PRNG using a `u64` seed.JG This is a convenience-wrapper around `from_seed` to allow constructionLI of any `SeedableRng` from a simple `u64` value. It is designed such that HE low Hamming Weight numbers like 0 and 1 can be used and should still!DA result in good, independent seeds to the PRNG which is returned.!!LI This **is not suitable for cryptography**, as should be clear given that"# the input size is only 64 bits.""HE Implementations for PRNGs *may* provide their own implementations of#KH this function, but the default implementation should be good enough for$JG all purposes. *Changing* the implementation of this function should be$'$ considered a value-breaking change.l$BGG J,%21(63 Create a new PRNG seeded from an infallible `Rng`.((LI This may be useful when needing to rapidly seed many PRNGs from a master)LI PRNG, and to allow forking of PRNGs. It may be considered deterministic.**JG The master PRNG should be at least as high quality as the child PRNGs.*DA When seeding non-cryptographic child PRNGs, we recommend using a+GD different algorithm for the master PRNG (ideally a CSPRNG) to avoid+GD correlations between the child PRNGs. If this is not possible (e.g.,JG forking using small non-crypto PRNGs) ensure that your PRNG has a good-IF mixing function on the output or consider use of a hash function with- `from_seed`.-.JG Note that seeding `XorShiftRng` from another `XorShiftRng` provides an.FC extreme example of what can go wrong: the new PRNG will be a clone/ of the parent.//JG PRNG implementations are allowed to assume that a good RNG is provided0JG for seeding, and that it is cryptographically secure when appropriate.0GD As of `rand` 0.7 / `rand_core` 0.5, implementations overriding this1EB method should ensure the implementation satisfies reproducibility1.+ (in prior versions this was not required).22" [`rand`]: https://docs.rs/randD2 BGLL 2G422 Ka 25J4?< Create a new PRNG seeded from a potentially fallible `Rng`.44FC See [`from_rng`][SeedableRng::from_rng] docs for more information.d5 BGNN 5G4545 Me 5876 Fork this PRNG77NK This creates a new PRNG from the current one by initializing a new one and7$! seeding it from the current one.8885 This is useful when initializing a PRNG for a thread$8 BG 8G9 O$8;S999N:$::96 This is useful when initializing a PRNG for a thread.;;<9 This is the failable equivalent to [`SeedableRng::fork`]D; BG ;G4< P$;=$,=C λB =,= ="t==Ct==CtT`T UW dUX 4&UY,:<(*'[[ 4\]^_]_^02T,ZZ}6d ÜĜŜƜǜȜ_wBZ Z ]$6d ÜĜŜƜǜȜ_wBZ Z ^$  Gt   ZÜĜŜƜǜȜ_wBZ Z _$ j 8L U}Baa   `h$& 3cc d  1efef4 4   ŦE" g  M  Reborrow with a new lifetime  KH Rust allows references like `&T` or `&mut T` to be "reborrowed" through PM coercion: essentially, the pointer is copied under a new, shorter, lifetime.IF Until rfcs#1403 lands, reborrows on user types require a method call.    ŦE"  Bd hhd  g $D$jmv.+ A marker trait for supported "word" types.GK*' This is implemented for: `u32`, `u64`.$jjv!ntj'Ӽ3Ӽ+T4inI4nn< $"thni^UI@7ymd[opqrsopqrso,<Z\Z\>4'пprsq7,nn-lBnn p,$\Bnn q$"T"Bnn rT"Bnn s$uwxyzopqrsywzxT,ttλ ",loBtt wm#\Btt xm!T"Btt ylT"Btt z l|~opqrs~T , {{ " ,l oB{{ ~k #\ B{{ rk !T "B{{ j T "B{{ -j̴kcac )1. Trait for infallible random number generatorsA> `Rng` is a sub-trait of [`TryRng`] for infallible generators. # Requirements63 See [`TryRng`#Requirements] which also apply here.\ # UsageGD The [`rand`] crate provides higher level functionality, for exampleNK generation of floating-point values, uniform ranged sampling and shufflingOL sequences. In particular, [`rand::RngExt`] is an extension trait over `Rng`OL providing many of the methods one might expect to be able to use on an RNG.Ĉ # Implementing `Rng`VS Implement [`TryRng`] with type Error = [core::convert::Infallible][]. # [`rand`]: https://docs.rs/rand/ HE [`rand::RngExt`]: https://docs.rs/rand/latest/rand/trait.RngExt.html # [`fill_bytes`]: Rng::fill_bytes  [`next_u32`]: Rng::next_u32  [`next_u64`]: Rng::next_u64   } 62&HD8  ! Return the next random `u32`.D  B  $   ! Return the next random `u64`.D  B  $ ) ! Fill `dest` with random data.  ?< This method should guarantee that `dest` is entirely filled 63 with new data, and may panic if this is impossible B? (e.g. reading past the end of a file that is being used as theԉ source of randomness).T  ZB  $C}4 D B  $D B  $(T  ZB  $p;=: A marker trait for securely unpredictable infallible RNGs[X This is a convenient trait alias for [TryCryptoRng].JG It is equivalent to the trait sum [Rng] + [TryCryptoRng].L> ;8/,SPGDJ 4 7C@ Base trait for random number generators and random data sourcesOL This trait provides a base interface designed to support efficient usage ofMJ (`u32`, `u64`) word generators, block generators and random data sources.NK There is no required relationship between the output of each method or anyOL requirement to use all generated random bits; for example an implementationPM of [`try_fill_bytes`](Self::try_fill_bytes) may discard some generated bytes41 to avoid storing a partially used word or block. ### Quality and lengthLI Implementions should produce bits uniformly: each output value should beHE equally likely, without observable patterns in successive outputs orOL between the output streams of multiple instances of an implementation usingGD different seeds or streams (where supported by the implementation).LI Pathological implementations (e.g. constant or counting generators whichNK rarely change some bits) may cause issues in consumers of random data, forLI example dead-locks in rejection samplers and obviously non-random outputNK (e.g. a counting generator may result in apparently-constant output from a! uniform-ranged distribution).NK Cryptographically unpredictable output is not a requirement of this trait,-* but is a requirement of [`TryCryptoRng`].PM In practice, most implementations are pseudo-random number generators with a JG finite *period* or *cycle length*, and (among non-cryptographic PRNGs)!C@ statistical anomalies may appear long before a cycle occurs. An!HE implementation should ensure its period is sufficiently long that no"LI anomalies are likely to appear in usage and/or document its limitations.""NK For more on PRNG quality and period, see [The Rust Rand Book: Quality][0].##C@ [0]: https://rust-random.github.io/book/guide-rngs.html#quality$$ ### Reproducibility$$LI Algorithmic generators implementing [`SeedableRng`] should normally have$OL *portable, reproducible* output, i.e. fix Endianness when converting values%LI to avoid platform differences, and avoid making any changes which affect&KH output (except by communicating that the release has breaking changes).&63 See also [The Rust Rand Book: Reproducibility][1].''=: [1]: https://rust-random.github.io/book/crate-reprod.html'\'''GD Often, usage of the infallible trait [`Rng`] or its extension trait(>; [`rand::RngExt`] is preferred to direct usage of `TryRng`.(ZW Many implementations of `TryRng` (those with type Error = [Infallible][]))QN already implement [`Rng`]; in other cases [`UnwrapErr`] may be used to obtain*! an implementation of [`Rng`].** # Implementing `TryRng`**OL Most algorithmic generators (i.e. pseudo-random number generators or PRNGs)+PM never fail; in this case type `Error` should be [`Infallible`]; in this case,JG trait `Rng` is implemented automatically. Cycling is not considered anT, error.,,;8 Small PRNGs often yield either `u32` or `u64` natively.-OL Module [`crate::utils`] provides utilities to help implement other methods.--GD Byte sources may implement [`try_fill_bytes`](Self::try_fill_bytes)l. natively..O//PM Block generators (which produce `[u32; N]` or `[u64; N]` for some fixed `N`)/30 should make use of the [`crate::block`] module.00! With regards to other traits:00LI - **Do not** implement [`Default`] for seedable pseudorandom generators,1FC though the trait may be implemented for stateless interfaces and1 auto-seeding generators.2PM - **Do** implement [`SeedableRng`] for seedable pseudorandom generators. See20- [Reproducibility](#reproducibility) above.3OL - Implement [`Clone`] for non-cryptographic PRNGs but consider not doing so3OL for cryptographic generators to avoid the risk of key-stream duplication.4NK - **Do not** implement [`Copy`] since accidental copies may cause repeatedl4 values.5LI - Implement [`Debug`](core::fmt::Debug), except that cryptographic PRNGs5PM should use a custom implementation which avoids leaking internal state (or6/, the subset of this derived from the key).6QN - [`Eq`] and [`PartialEq`] could be implemented, but are probably not useful.77H477"99ƅ؅982/ The type returned in the event of a RNG error.88XU Use type [`Infallible`] (re-exported by `rand_core`) for infallible implementations.,9979!d9 ÜĜŜƜǜȜ_wB 9 $::7:!d: ÜĜŜƜǜȜ_wB : $:;H;)& Fill `dst` entirely with random data.t;  ZÜĜŜƜǜȜ_wB ; $;;<; <"D<4<NPT<,<=6d= zB = $==6d> }B > $>>Gt>  ZB ? $?K?B? A marker trait over [`TryRng`] for securely unpredictable RNGs@@LI This marker trait indicates that the implementing generator is intended,AKH when correctly seeded and protected from side-channel attacks such as aAOL leaking of state, to be a cryptographically secure generator. This trait isBKH provided as a tool to aid review of cryptographic code, but does not byB@= itself guarantee suitability for cryptographic applications.CCPM Formally, a CSPRNG (Cryptographically Secure Pseudo-Random Number Generator)DNK should satisfy an additional property over other generators: assuming thatDKH the generator has been appropriately seeded and has unknown state, thenE52 given the first *k* bits of an algorithm's outputEKH sequence, it should not be possible using polynomial-time algorithms toFIF predict the next bit with probability significantly greater than 50%.FFOL An optional property of CSPRNGs is backtracking resistance: if the CSPRNG'sGMJ state is revealed, it will not be computationally-feasible to reconstructHFC prior output values. This property is not required by `CryptoRng`.HHIF Implementors of `TryCryptoRng` should only implement [`Default`] if aIJG default-constructed instance is itself a secure generator, for exampleI96 [`getrandom::SysRng`] which is a stateless interface.JJXU [`getrandom::SysRng`]: https://docs.rs/getrandom/latest/getrandom/struct.SysRng.htmldKK!4K# /,KB KҌDKdK!MKa^ DEPRECATED: stub trait to print a deprecation warning and aid discovering that [`Rng`] is theL replacement.0.10.0use `Rng` insteadMM;TOՠOX4O# /,PPP|P Error type.,PՠP  P4PTP,P{!/, RNG functionality for a block [`Generator`]LI This type encompasses a [`Generator`] [`core`](Self::core) and a buffer.LI It provides optimized implementations of methods required by an [`Rng`].NK All values are consumed in-order of generation. No whole words (e.g. `u32`NK or `u64`) are discarded, though where a word is partially used (e.g. for aNK byte-fill whose length is not a multiple of the word size) the rest of the word is discarded. [`Rng`]: crate::RngD ƭLFFچB)+<\EB The *core* part of the RNG, implementing the `generate` function.$8  ƭ8 8 8  B 8 K0QN Wrapper around [`TryRng`] implementation which implements [`Rng`][crate::Rng]%" by panicking on potential errors.t # Examples\ ```rust.+ # use rand_core::{UnwrapErr, TryRng, Rng};,) fn with_try_rng(mut rng: R) {! // rng does not impl Rng:+( let _ = rng.try_next_u32(); // okay+( // let _ = rng.next_u32(); // error$! // An adapter borrowing rng:/, let _ = UnwrapErr(&mut rng).next_u32();! // An adapter moving rng:%" let mut rng = UnwrapErr(rng); let _ = rng.next_u32();,C@ fn call_with_unsized_try_rng(rng: &mut R) {1. // R is unsized, thus we must use &mut R:%ΰ,<L 4ŦE"BKTB km,ggggg  ggg cgcثq1ȡB gghhhB tiHWpstiti B ti  jETmpjjjj B jj"03jaGfjj  B j j>kh+hDG>k>k  B>ki>k >k>k>k>k3 3y3 3 3y3 3L33333|3h3|~3}3|3{3 B3m3k3j3h3M3GL3J3I3JI393?3g33333(3.3G3.G3|F3 373N7353 34343F43 3333 ;3.33z3 ?3&+d MIT license"http://opensource.org/licenses/MIT2https://docs.rs/rand/latest/rand/trait.RngExt.htmlcore::fmt::Debugg core::fmtgetrandom::SysRngrand  Apache License, Version 2.0*http://www.apache.org/licenses/LICENSE-2.0core::convert::InfallibleReproducibilityc https://docs.rs/rand rand::RngExt crate::utilsgWhttps://github.com/rust-random/rand_core/actions/workflows/test.yml?query=branch:masterhttps://docs.rs/rand/e4https://rust-random.github.io/book/crate-reprod.html r Build StatusTryRng#Requirements#The Rust Rand Book: Reproducibility 2reqg~Apache2/MIT licensed 2https://rust-random.github.io/book/guide-rngs.html req~https://docs.rs/rand_coreThe Rust Rand Book: Quality Go q~Docs;https://img.shields.io/badge/license-Apache2.0/MIT-blue.svgSelf::try_fill_bytes o"https://crates.io/crates/rand_core#https://docs.rs/rand_core/badge.svg Rng::next_u64=https://docs.rs/getrandom/latest/getrandom/struct.SysRng.htmlo -https://img.shields.io/crates/v/rand_core.svg Rng::next_u32[https://github.com/rust-random/rand_core/actions/workflows/test.yml/badge.svg?branch=masterRng::fill_bytes crate::block getrandom core::convert   6Drop#rand_core::blockSelf::remaining_results Self::OutputBlockRng::next_word crate::TryRng Self::core   crate::SeedableRng rand_core crate::Rng   G   $"Does It Beat the Minimal Standard? ;Ghttps://www.pcg-random.org/posts/does-it-beat-the-minimal-standard.html SeedableRng::Seedcrate::SeedableRng::Seed H  > 5G  7SeedableRng::from_rngrSeedableRng::forkOrKGr       jP´  ####!!!PQPPQjP´  ####!!!PQPPQGP´  ####!!!PQPPQP´  ####!!!PQPPQ"GP´  ####!!!PQPPQBlockRngcore)assertion failed: 0 < index && index <= N)assertion failed: n < N UnwrapErr +(rand_core::UnwrapErr: failed to unwrap: +8S#ʀ4d]ԁLN OP(kN67=q'8Εmbr7ZYq X5-H2bESSxRђYg §|i_ X&l[ M6g[#TMNn_EFND3q:aJ;,Rkc'z-7^nqL`)@Ac/mۯàO3@Y?dξ7] UB"zM 4=Ԩed2S'Va;@A,>'%8M~$U6z;lnfMQ>ӀϔpSYZgj{Rr]K<pldw9P|A6xDtSZpUX#l $tcs,PmD GL!olBRTmL+sTrN;C he[AmB`a{]q\P[?oNџ+ll?w{SLl2Z5[L!'r mj"|ݻŮ!>a˜]sV7W1uo%`&o/1\M\E^2q,Lr:&T#lUIv}kחGU̶Ȱ3;Td}? ڀڢ<˯YهGpƝGq&v Β'1NJ_-֞ˮF")4rG3NwJtMX(1K8u17z٪QtS{7xqz&'!ǽ6='<+BجY6Be8ħ`!rwC9Y߸"l@'s8 rJLhJ@S!{ŁG6l^Mo|QEӯQ(twYK8g䶍0L˾ֹI#%UD}R6A*¼9Vu逃[ˈ`63!+X.p'lLn|$Za)HD;L S~rnzzuw,2+YzFX<g5٨K28%[C-ˆEm07ԆW-ԭiZ|$灯F?^wTNwsQXs /|KZp_fݖؗ3[9ogPE`bg=( pC.|  P-jnu|Ks1ufx% cvhwfYFwy} B3JS\^bfm>zE-:0>,m P>f%ahp69KhJYI,Ge(uV a{GMW>Vc IN5 8 4"LdZeEZg( +6<"cJ)19y                                '           ʕ2/¢ ¶L]8oHAV36DD#hB~=ycz5o'0_  *{5 e^Idn(agjqxȒΒԒon{,dqėjwaޚR_gtś ^qc]erjwbz-:Btw{=EN Y\`dh9hu+1@#)7 ,9'iK:Ra!]dk248Gc7FD(Ba#dqQP]w5D=JET9zS`Yhnu{     ! ' - 3 9 ? E K Q W ] d j p v }            dnu̒Ғpfuly{Taixʛ_gly~/<Hy}Y4W0m)^bf>j/5}'/2@,m P>f%ahah<Kv;1W,G f&w1Ra8GE?MHW}\krx      $ * 0 6 < B H N T Z a g m s z             +|6۔3xFntF\q <VHءo3t\JJ7pA|-g '5r='WV;z K\N DGC ?%:E ?nLLm!ZpA`GQ&W@oF|e ϔ r3h˗n>Vk0J<̡iܢn33ȳ&ܶ1^9yc![ot"l|7!E N3rCV F>|:{=61x8 *h8CX Tg;wKAKvB2Z8g_ߔbXc}JCe@ZLܡXce}`kg}@@z +X)Z?~O^R%L4?Ja3u'r/7+wEK@30 pI BWE$i>zdp(` _Jeo̕63Ţţ ŶqK CXF$i>{eq)a`fpy|Λ[4q-B0qTj)elO[KJPZe o   & / 8 B L V ` j " y ,zpv^sqv9t?FE' p^\CISgB |!+;<!BLMQ9Zj`Zbeufkl8noFrsstguvwwxcy@z{{}~ gh9iiz{{}~G h7ii:jkk {!+;< BLLQYi`YbetfPgl7noErrstfuxvwwxby?z{{}~H h8ii;jkk^grgg svbgvggsv ZPj\ rw&G2` aCW-TR3MSLN- _1ɗ~FWmz-0>t ($uVC@XeB5t "&8<@GNUY`p +/3JQpw~  +;O^ex0@^bimv} '.5<@GKRY`gkoy"*2:MQYgks #+26>FJRV^fjrv~ !'-39?EKRY`gnu| EOfge[ghKLMNOP[h$%&'())z{|}#'"#$!&Dstu +3; )*@,,(.'"-"-#-m".`hj`iQ\i** +~+%+6v"c08@yQ),/25%(+.14!96$'*  0#&33 \38S#С ]8S#&HkV[:$crate::panic::panic_2021  7`panic_internals[Z8S#}>4 !38S#V~T~ \'38S#ʫx&T 4Ƥ2y'8Lm̟vɢ.2l\l" {v [\ܥ\"<]f֝$LۡiLF̠ͣ.(z4ODHT P[?oNKHD;ѪML.l cVĉ*¼9V]K92k5g3@k̲j䶍0La淘u{Rr84El ?zzuwp&v eUB"zMM~$$xqz&'ӯQ(twȍpJ*Bm܆1Dɀؗ3[߄4*rA65ҽ2nN6L,>'%8#s;n;?ys׌8AR»%=AOC-D:vspƝGqdBGUL!'PM֦pp'lLnz٪QtS}lBRTmDESSx L+sTrE0 V;˅FWLY+,2+Yz[O\M\X4d]ԁL˜]sTZp_fݖb0b*B$tcs@=Ԩed&*g[rK]g"f|i_ G#bixHClt1c/mۯ>;lnfM3Yo^Z0*r mQ6l^8 rJL6AU6z%f*ӵt)mI>Ӏϔ5brc'zIv\ aڀץ<p:`@ߴ+X.`)|K[~%>")4xld;u~P֫j"|RJN%uw'Va!V7W1uU'1fàO3@[}3=g0!ǽ6='<YK8gK28%[Q;٫7saSX<9ogLPoVD&Fyo(fQi61E^2q,YufU6g[#T@S!{ŁT#lU['8Εm}Hϕm&ΧٷLl2M˯YهGcpor2pS6UB0OqP27] f}+k9qݼ5ʰz8S# B8 }? a໧6-lYZgj7 he[AG/ f6rQ4h&|+%3S5&N9IR] g&EJd{@u&q:Fs 2sru7@?"u&&p'C YIwk-0p3|h qtX**@* 6[_b)(bEg=eD 5}xh&|+%X/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/block.rsK/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1X/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/block.rs p1s*d7vJKK-N=OLMON#/1# <.# *+!1#=' !@# @+ S) 9+1.(d*27#J140MMOOO$JO#=%'%*+UB=)-'#@I%;K-)5A/- K.NM%,00BHLNL1 /FK)"+5KJB,.",'&3 )#D.1"&*#&3"& #.K4&&72F8<+_!+,J8(P @ +Cǰt+pX/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/utils.rsK/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1X/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/utils.rs ẦLfJ2=&&*OKI"MFELM#!)202>$L5(4OKQ#6"1N, !@/ @N& QI /.7 .< TA,,,BL -1; ;'.9 6T0'.H 9C7)354-&H*$b$#_/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/seedable_rng.rsK/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1_/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/seedable_rng.rs gLRىw{_uAA=FHNOPJL P6PQ'O?QOI $+%%(" )( )0 %#5 <0MMRMP!PMQPAHQC%OMNPQ,.OQMIQ(MPO,/.:!7 )B ;QQOILLONOKOOLJ3'8.'DKQ.,"S)= S)>A8 !',,E+89=$*]޽,c#m]/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/unwrap_err.rsK/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1]/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/unwrap_err.rs IsV]U F/R& /-",,%0"& D2& <(*=1=1N6;<74%PUN8 @X*Xe.j,W/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/word.rsK/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1W/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/word.rs `LJ+IC&#d B/+" 6PA6-+&7' .$ ,$ '% 7' .$ ,$ '% r Vnj.AlV/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/lib.rsK/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1V/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.10.1/src/lib.rs ZK澷ïB38QQ#0 'Q?# #2B7 HOPPW$I$ ,&#&#&D;G.,$$ $$ /) >\K?NDPNOPQ5MIPHMOMO"O.QKDIMODMPML7> H?[R"PQK