Struct prop_check_rs::rng::RNG

pub struct RNG { /* private fields */ }

Implementations

impl RNG

pub fn new() -> Self

Examples found in repository

src/rng.rs (line 102)

  fn default() -> Self {
    Self::new()
  }

pub fn new_with_seed(seed: u64) -> Self

pub fn i32_f32(&self) -> ((i32, f32), Self)

Examples found in repository

src/rng.rs (line 194)

  pub fn f32_i32(&self) -> ((f32, i32), Self) {
    let ((i, d), r) = self.i32_f32();
    ((d, i), r)
  }

pub fn f32_i32(&self) -> ((f32, i32), Self)

pub fn f32_3(&self) -> ((f32, f32, f32), Self)

pub fn i32s(self, count: u32) -> (Vec<i32>, Self)

pub fn unit<A>(a: A) -> Box<dyn FnMut(RNG) -> (A, RNG)>where
    A: Clone + 'static,

Examples found in repository

src/rng.rs (line 228)

  pub fn sequence<A, F>(fs: Vec<F>) -> BoxRand<Vec<A>>
  where
    A: Clone + 'static,
    F: FnMut(RNG) -> (A, RNG) + 'static, {
    let unit = Self::unit(Vec::<A>::new());
    let result = fs.into_iter().fold(unit, |acc, e| {
      Self::map2(acc, e, |mut a, b| {
        a.push(b);
        a
      })
    });
    result
  }

pub fn sequence<A, F>(fs: Vec<F>) -> Box<dyn FnMut(RNG) -> (Vec<A>, RNG)>where
    A: Clone + 'static,
    F: FnMut(RNG) -> (A, RNG) + 'static,

pub fn int_value() -> Box<dyn FnMut(RNG) -> (i32, RNG)>

Examples found in repository

src/rng.rs (line 276)

  pub fn rand_int_double() -> BoxRand<(i32, f32)> {
    Self::both(Self::int_value(), Self::double_value())
  }

  pub fn rand_double_int<'a>() -> BoxRand<(f32, i32)> {
    Self::both(Self::double_value(), Self::int_value())
  }

pub fn double_value() -> Box<dyn FnMut(RNG) -> (f32, RNG)>

Examples found in repository

src/rng.rs (line 276)

  pub fn rand_int_double() -> BoxRand<(i32, f32)> {
    Self::both(Self::int_value(), Self::double_value())
  }

  pub fn rand_double_int<'a>() -> BoxRand<(f32, i32)> {
    Self::both(Self::double_value(), Self::int_value())
  }

pub fn map<A, B, F1, F2>(s: F1, f: F2) -> Box<dyn FnMut(RNG) -> (B, RNG)>where
    F1: FnMut(RNG) -> (A, RNG) + 'static,
    F2: FnMut(A) -> B + 'static,

pub fn map2<F1, F2, F3, A, B, C>(
    ra: F1,
    rb: F2,
    f: F3
) -> Box<dyn FnMut(RNG) -> (C, RNG)>where
    F1: FnMut(RNG) -> (A, RNG) + 'static,
    F2: FnMut(RNG) -> (B, RNG) + 'static,
    F3: FnMut(A, B) -> C + 'static,

Examples found in repository

src/rng.rs (lines 230-233)

  pub fn sequence<A, F>(fs: Vec<F>) -> BoxRand<Vec<A>>
  where
    A: Clone + 'static,
    F: FnMut(RNG) -> (A, RNG) + 'static, {
    let unit = Self::unit(Vec::<A>::new());
    let result = fs.into_iter().fold(unit, |acc, e| {
      Self::map2(acc, e, |mut a, b| {
        a.push(b);
        a
      })
    });
    result
  }

  pub fn int_value() -> BoxRand<i32> {
    Box::new(move |rng| rng.next_i32())
  }

  pub fn double_value() -> BoxRand<f32> {
    Box::new(move |rng| rng.next_f32())
  }

  pub fn map<A, B, F1, F2>(mut s: F1, mut f: F2) -> BoxRand<B>
  where
    F1: FnMut(RNG) -> (A, RNG) + 'static,
    F2: FnMut(A) -> B + 'static, {
    Box::new(move |rng| {
      let (a, rng2) = s(rng);
      (f(a), rng2)
    })
  }

  pub fn map2<F1, F2, F3, A, B, C>(mut ra: F1, mut rb: F2, mut f: F3) -> BoxRand<C>
  where
    F1: FnMut(RNG) -> (A, RNG) + 'static,
    F2: FnMut(RNG) -> (B, RNG) + 'static,
    F3: FnMut(A, B) -> C + 'static, {
    Box::new(move |rng| {
      let (a, r1) = ra(rng);
      let (b, r2) = rb(r1);
      (f(a, b), r2)
    })
  }

  pub fn both<F1, F2, A, B>(ra: F1, rb: F2) -> BoxRand<(A, B)>
  where
    F1: FnMut(RNG) -> (A, RNG) + 'static,
    F2: FnMut(RNG) -> (B, RNG) + 'static, {
    Self::map2(ra, rb, |a, b| (a, b))
  }

pub fn both<F1, F2, A, B>(ra: F1, rb: F2) -> Box<dyn FnMut(RNG) -> ((A, B), RNG)>where
    F1: FnMut(RNG) -> (A, RNG) + 'static,
    F2: FnMut(RNG) -> (B, RNG) + 'static,

Examples found in repository

src/rng.rs (line 276)

  pub fn rand_int_double() -> BoxRand<(i32, f32)> {
    Self::both(Self::int_value(), Self::double_value())
  }

  pub fn rand_double_int<'a>() -> BoxRand<(f32, i32)> {
    Self::both(Self::double_value(), Self::int_value())
  }

pub fn rand_int_double() -> Box<dyn FnMut(RNG) -> ((i32, f32), RNG)>

pub fn rand_double_int<'a>() -> Box<dyn FnMut(RNG) -> ((f32, i32), RNG)>

pub fn flat_map<A, B, F, GF, BF>(f: F, g: GF) -> Box<dyn FnMut(RNG) -> (B, RNG)>where
    F: FnMut(RNG) -> (A, RNG) + 'static,
    BF: FnMut(RNG) -> (B, RNG) + 'static,
    GF: FnMut(A) -> BF + 'static,

Trait Implementations

impl Clone for RNG

fn clone(&self) -> RNG

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RNG

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RNG

fn default() -> Self

Returns the “default value” for a type.

impl NextRandValue for RNG

fn next_i64(&self) -> (i64, Self)

fn next_u64(&self) -> (u64, Self)

fn next_i32(&self) -> (i32, Self)

fn next_u32(&self) -> (u32, Self)

fn next_i16(&self) -> (i16, Self)

fn next_u16(&self) -> (u16, Self)

fn next_i8(&self) -> (i8, Self)

fn next_u8(&self) -> (u8, Self)

fn next_f64(&self) -> (f64, Self)

fn next_f32(&self) -> (f32, Self)

fn next_bool(&self) -> (bool, Self)

impl PartialEq<RNG> for RNG

fn eq(&self, other: &RNG) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RNG