Trait fake::Dummy

pub trait Dummy<T>: Sized {
    fn dummy_with_rng<R: Rng + ?Sized>(config: &T, rng: &mut R) -> Self;

    fn dummy(config: &T) -> Self { ... }
}

Required Methods

fn dummy_with_rng<R: Rng + ?Sized>(config: &T, rng: &mut R) -> Self

Provided Methods

fn dummy(config: &T) -> Self

Implementations on Foreign Types

impl<T, U> Dummy<U> for [T; 32] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 31] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 30] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 29] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 28] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 27] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 26] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 25] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 24] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 23] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 22] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 21] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 20] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 19] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 18] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 17] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 16] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 15] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 14] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 13] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 12] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 11] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 10] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 9] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 8] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 7] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 6] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 5] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 4] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 3] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 2] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 1] where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for [T; 0] where
    T: Dummy<U>, 

fn dummy(_: &U) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(_: &U, _rng: &mut R) -> Self

impl<T> Dummy<Faker> for BinaryHeap<T> where
    T: Dummy<Faker> + Ord, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T, E, L> Dummy<(E, L)> for BinaryHeap<T> where
    T: Dummy<E> + Ord,
    usize: Dummy<L>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &(E, L), rng: &mut R) -> Self

impl<K, V> Dummy<Faker> for BTreeMap<K, V> where
    K: Dummy<Faker> + Ord,
    V: Dummy<Faker>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T> Dummy<Faker> for BTreeSet<T> where
    T: Dummy<Faker> + Ord, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<K, V, S> Dummy<Faker> for HashMap<K, V, S> where
    K: Dummy<Faker> + Hash + Eq,
    V: Dummy<Faker>,
    S: BuildHasher + Default, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T, S> Dummy<Faker> for HashSet<T, S> where
    T: Dummy<Faker> + Hash + Eq,
    S: BuildHasher + Default, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T> Dummy<Faker> for LinkedList<T> where
    T: Dummy<Faker>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T, E, L> Dummy<(E, L)> for LinkedList<T> where
    T: Dummy<E>,
    usize: Dummy<L>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &(E, L), rng: &mut R) -> Self

impl<T> Dummy<Faker> for Vec<T> where
    T: Dummy<Faker>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T, E, L> Dummy<(E, L)> for Vec<T> where
    T: Dummy<E>,
    usize: Dummy<L>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &(E, L), rng: &mut R) -> Self

impl<T> Dummy<Faker> for VecDeque<T> where
    T: Dummy<Faker>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T, E, L> Dummy<(E, L)> for VecDeque<T> where
    T: Dummy<E>,
    usize: Dummy<L>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &(E, L), rng: &mut R) -> Self

impl<T, U> Dummy<U> for Box<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for Cell<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for RefCell<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for Rc<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for Arc<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for Mutex<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for RwLock<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl<T, U> Dummy<U> for Pin<T> where
    T: Dummy<U> + Deref,
    <T as Deref>::Target: Unpin, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl Dummy<Faker> for Ipv4Addr

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Faker> for Ipv6Addr

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Faker> for IpAddr

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Faker> for SocketAddrV4

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Faker> for SocketAddrV6

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl<T, U> Dummy<U> for Option<T> where
    T: Dummy<U>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &U, rng: &mut R) -> Self

impl Dummy<Faker> for PathBuf

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl<'a> Dummy<PathFaker<'a>> for PathBuf

fn dummy_with_rng<R: Rng + ?Sized>(c: &PathFaker<'a>, rng: &mut R) -> Self

impl Dummy<()> for ()

fn dummy(t: &()) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &(), _rng: &mut R) -> Self

impl Dummy<Faker> for ()

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<bool> for bool

fn dummy(t: &bool) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &bool, _rng: &mut R) -> Self

impl Dummy<Faker> for bool

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<char> for char

fn dummy(t: &char) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &char, _rng: &mut R) -> Self

impl Dummy<Faker> for char

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<u8> for u8

fn dummy(t: &u8) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &u8, _rng: &mut R) -> Self

impl Dummy<Faker> for u8

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<u8>> for u8

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<u8>> for u8

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<u8>> for u8

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for u8

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<u8>> for u8

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<u8>> for u8

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<u8>> for u8

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<u16> for u16

fn dummy(t: &u16) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &u16, _rng: &mut R) -> Self

impl Dummy<Faker> for u16

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<u16>> for u16

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<u16>> for u16

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<u16>> for u16

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for u16

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<u16>> for u16

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<u16>> for u16

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<u16>> for u16

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<u32> for u32

fn dummy(t: &u32) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &u32, _rng: &mut R) -> Self

impl Dummy<Faker> for u32

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<u32>> for u32

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<u32>> for u32

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<u32>> for u32

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for u32

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<u32>> for u32

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<u32>> for u32

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<u32>> for u32

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<u64> for u64

fn dummy(t: &u64) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &u64, _rng: &mut R) -> Self

impl Dummy<Faker> for u64

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<u64>> for u64

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<u64>> for u64

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<u64>> for u64

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for u64

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<u64>> for u64

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<u64>> for u64

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<u64>> for u64

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<u128> for u128

fn dummy(t: &u128) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &u128, _rng: &mut R) -> Self

impl Dummy<Faker> for u128

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<u128>> for u128

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<u128>> for u128

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<u128>> for u128

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for u128

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<u128>> for u128

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<u128>> for u128

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<u128>> for u128

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<usize> for usize

fn dummy(t: &usize) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &usize, _rng: &mut R) -> Self

impl Dummy<Faker> for usize

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<usize>> for usize

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<usize>> for usize

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<usize>> for usize

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for usize

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<usize>> for usize

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<usize>> for usize

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<usize>> for usize

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<i8> for i8

fn dummy(t: &i8) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &i8, _rng: &mut R) -> Self

impl Dummy<Faker> for i8

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<i8>> for i8

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<i8>> for i8

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<i8>> for i8

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for i8

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<i8>> for i8

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<i8>> for i8

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<i8>> for i8

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<i16> for i16

fn dummy(t: &i16) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &i16, _rng: &mut R) -> Self

impl Dummy<Faker> for i16

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<i16>> for i16

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<i16>> for i16

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<i16>> for i16

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for i16

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<i16>> for i16

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<i16>> for i16

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<i16>> for i16

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<i32> for i32

fn dummy(t: &i32) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &i32, _rng: &mut R) -> Self

impl Dummy<Faker> for i32

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<i32>> for i32

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<i32>> for i32

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<i32>> for i32

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for i32

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<i32>> for i32

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<i32>> for i32

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<i32>> for i32

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<i64> for i64

fn dummy(t: &i64) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &i64, _rng: &mut R) -> Self

impl Dummy<Faker> for i64

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<i64>> for i64

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<i64>> for i64

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<i64>> for i64

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for i64

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<i64>> for i64

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<i64>> for i64

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<i64>> for i64

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<i128> for i128

fn dummy(t: &i128) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &i128, _rng: &mut R) -> Self

impl Dummy<Faker> for i128

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<i128>> for i128

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<i128>> for i128

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<i128>> for i128

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for i128

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<i128>> for i128

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<i128>> for i128

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<i128>> for i128

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<isize> for isize

fn dummy(t: &isize) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &isize, _rng: &mut R) -> Self

impl Dummy<Faker> for isize

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<isize>> for isize

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<isize>> for isize

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<isize>> for isize

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for isize

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<isize>> for isize

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<isize>> for isize

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<isize>> for isize

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<f32> for f32

fn dummy(t: &f32) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &f32, _rng: &mut R) -> Self

impl Dummy<Faker> for f32

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<f32>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<f32>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<f32>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for f32

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<f32>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<f32>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<f32>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<f64> for f64

fn dummy(t: &f64) -> Self

fn dummy_with_rng<R: Rng + ?Sized>(t: &f64, _rng: &mut R) -> Self

impl Dummy<Faker> for f64

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Uniform<f64>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(dist: &Uniform<Self>, rng: &mut R) -> Self

impl Dummy<Range<f64>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<Self>, rng: &mut R) -> Self

impl Dummy<RangeFrom<f64>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFrom<Self>, rng: &mut R) -> Self

impl Dummy<RangeFull> for f64

fn dummy_with_rng<R: Rng + ?Sized>(_: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<f64>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<Self>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<f64>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<Self>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<f64>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<Self>,
    rng: &mut R
) -> Self

impl<T, E> Dummy<Faker> for Result<T, E> where
    T: Dummy<Faker>,
    E: Dummy<Faker>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T, E, U, V> Dummy<ResultFaker<U, V>> for Result<T, E> where
    T: Dummy<U>,
    E: Dummy<V>, 

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &ResultFaker<U, V>,
    rng: &mut R
) -> Self

impl Dummy<usize> for String

fn dummy_with_rng<R: Rng + ?Sized>(len: &usize, rng: &mut R) -> Self

impl Dummy<Faker> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

impl Dummy<Range<usize>> for String

fn dummy_with_rng<R: Rng + ?Sized>(range: &Range<usize>, rng: &mut R) -> Self

impl Dummy<RangeFrom<usize>> for String

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeFrom<usize>,
    rng: &mut R
) -> Self

impl Dummy<RangeFull> for String

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeFull, rng: &mut R) -> Self

impl Dummy<RangeInclusive<usize>> for String

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeInclusive<usize>,
    rng: &mut R
) -> Self

impl Dummy<RangeTo<usize>> for String

fn dummy_with_rng<R: Rng + ?Sized>(range: &RangeTo<usize>, rng: &mut R) -> Self

impl Dummy<RangeToInclusive<usize>> for String

fn dummy_with_rng<R: Rng + ?Sized>(
    range: &RangeToInclusive<usize>,
    rng: &mut R
) -> Self

impl<L> Dummy<StringFaker<L>> for String where
    usize: Dummy<L>, 

fn dummy_with_rng<R: Rng + ?Sized>(config: &StringFaker<L>, rng: &mut R) -> Self

impl<A: Dummy<Faker>> Dummy<Faker> for (A,)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>> Dummy<(T0,)> for (A,)

fn dummy_with_rng<R: Rng + ?Sized>(config: &(T0,), rng: &mut R) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>> Dummy<Faker> for (A, B)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>> Dummy<(T0, T1)> for (A, B)

fn dummy_with_rng<R: Rng + ?Sized>(config: &(T0, T1), rng: &mut R) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>> Dummy<Faker> for (A, B, C)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>> Dummy<(T0, T1, T2)> for (A, B, C)

fn dummy_with_rng<R: Rng + ?Sized>(config: &(T0, T1, T2), rng: &mut R) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>> Dummy<Faker> for (A, B, C, D)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>> Dummy<(T0, T1, T2, T3)> for (A, B, C, D)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>> Dummy<(T0, T1, T2, T3, T4)> for (A, B, C, D, E)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>> Dummy<(T0, T1, T2, T3, T4, T5)> for (A, B, C, D, E, F)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>, G: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F, G)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>, T6, G: Dummy<T6>> Dummy<(T0, T1, T2, T3, T4, T5, T6)> for (A, B, C, D, E, F, G)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5, T6),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>, G: Dummy<Faker>, H: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F, G, H)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>, T6, G: Dummy<T6>, T7, H: Dummy<T7>> Dummy<(T0, T1, T2, T3, T4, T5, T6, T7)> for (A, B, C, D, E, F, G, H)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5, T6, T7),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>, G: Dummy<Faker>, H: Dummy<Faker>, I: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F, G, H, I)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>, T6, G: Dummy<T6>, T7, H: Dummy<T7>, T8, I: Dummy<T8>> Dummy<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for (A, B, C, D, E, F, G, H, I)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5, T6, T7, T8),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>, G: Dummy<Faker>, H: Dummy<Faker>, I: Dummy<Faker>, J: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F, G, H, I, J)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>, T6, G: Dummy<T6>, T7, H: Dummy<T7>, T8, I: Dummy<T8>, T9, J: Dummy<T9>> Dummy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for (A, B, C, D, E, F, G, H, I, J)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>, G: Dummy<Faker>, H: Dummy<Faker>, I: Dummy<Faker>, J: Dummy<Faker>, K: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F, G, H, I, J, K)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>, T6, G: Dummy<T6>, T7, H: Dummy<T7>, T8, I: Dummy<T8>, T9, J: Dummy<T9>, T10, K: Dummy<T10>> Dummy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for (A, B, C, D, E, F, G, H, I, J, K)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
    rng: &mut R
) -> Self

impl<A: Dummy<Faker>, B: Dummy<Faker>, C: Dummy<Faker>, D: Dummy<Faker>, E: Dummy<Faker>, F: Dummy<Faker>, G: Dummy<Faker>, H: Dummy<Faker>, I: Dummy<Faker>, J: Dummy<Faker>, K: Dummy<Faker>, L: Dummy<Faker>> Dummy<Faker> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn dummy_with_rng<R: Rng + ?Sized>(config: &Faker, rng: &mut R) -> Self

impl<T0, A: Dummy<T0>, T1, B: Dummy<T1>, T2, C: Dummy<T2>, T3, D: Dummy<T3>, T4, E: Dummy<T4>, T5, F: Dummy<T5>, T6, G: Dummy<T6>, T7, H: Dummy<T7>, T8, I: Dummy<T8>, T9, J: Dummy<T9>, T10, K: Dummy<T10>, T11, L: Dummy<T11>> Dummy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn dummy_with_rng<R: Rng + ?Sized>(
    config: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
    rng: &mut R
) -> Self

impl<L: Data> Dummy<CityPrefix<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CityPrefix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CityPrefix<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CityPrefix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CitySuffix<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CitySuffix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CitySuffix<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CitySuffix<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<CityName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &CityName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CountryName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CountryName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CountryName<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CountryName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CountryCode<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CountryCode<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CountryCode<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CountryCode<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<StreetSuffix<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &StreetSuffix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<StreetSuffix<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &StreetSuffix<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<StreetName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &StreetName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<TimeZone<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &TimeZone<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<TimeZone<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &TimeZone<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<StateName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &StateName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<StateName<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &StateName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<StateAbbr<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &StateAbbr<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<StateAbbr<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &StateAbbr<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<SecondaryAddressType<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(
    _: &SecondaryAddressType<L>,
    rng: &mut R
) -> Self

impl<L: Data> Dummy<SecondaryAddressType<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(
    _: &SecondaryAddressType<L>,
    rng: &mut R
) -> Self

impl<L: Data + Copy> Dummy<SecondaryAddress<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &SecondaryAddress<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<ZipCode<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &ZipCode<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<PostCode<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &PostCode<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<BuildingNumber<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &BuildingNumber<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Latitude<L>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(_: &Latitude<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Latitude<L>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(_: &Latitude<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Latitude<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Latitude<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Longitude<L>> for f64

fn dummy_with_rng<R: Rng + ?Sized>(_: &Longitude<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Longitude<L>> for f32

fn dummy_with_rng<R: Rng + ?Sized>(_: &Longitude<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Longitude<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Longitude<L>, rng: &mut R) -> Self

impl Dummy<HealthInsuranceCode<FR_FR>> for String

fn dummy_with_rng<R: Rng + ?Sized>(
    _: &HealthInsuranceCode<FR_FR>,
    rng: &mut R
) -> Self

impl<L: Data> Dummy<Boolean<L>> for bool

fn dummy_with_rng<R: Rng + ?Sized>(c: &Boolean<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CompanySuffix<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CompanySuffix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CompanySuffix<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CompanySuffix<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<CompanyName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &CompanyName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Buzzword<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Buzzword<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Buzzword<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Buzzword<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BuzzwordMiddle<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &BuzzwordMiddle<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BuzzwordMiddle<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &BuzzwordMiddle<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BuzzwordTail<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &BuzzwordTail<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BuzzwordTail<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &BuzzwordTail<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<CatchPhase<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &CatchPhase<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BsVerb<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &BsVerb<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BsVerb<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &BsVerb<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BsAdj<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &BsAdj<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BsAdj<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &BsAdj<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BsNoun<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &BsNoun<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<BsNoun<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &BsNoun<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Bs<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Bs<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Profession<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Profession<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Profession<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Profession<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Industry<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Industry<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Industry<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Industry<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CurrencyCode<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CurrencyCode<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CurrencyCode<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CurrencyCode<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CurrencyName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CurrencyName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CurrencyName<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CurrencyName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CurrencySymbol<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &CurrencySymbol<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CurrencySymbol<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &CurrencySymbol<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FilePath<L>> for PathBuf

fn dummy_with_rng<R: Rng + ?Sized>(_: &FilePath<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FilePath<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &FilePath<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FileName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &FileName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FileExtension<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &FileExtension<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FileExtension<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &FileExtension<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<DirPath<L>> for PathBuf

fn dummy_with_rng<R: Rng + ?Sized>(_: &DirPath<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<DirPath<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &DirPath<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Semver<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Semver<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<MimeType<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &MimeType<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Bic<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Bic<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FreeEmailProvider<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(
    _: &FreeEmailProvider<L>,
    rng: &mut R
) -> Self

impl<L: Data> Dummy<FreeEmailProvider<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(
    _: &FreeEmailProvider<L>,
    rng: &mut R
) -> Self

impl<L: Data> Dummy<DomainSuffix<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &DomainSuffix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<DomainSuffix<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &DomainSuffix<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<FreeEmail<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &FreeEmail<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<SafeEmail<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &SafeEmail<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Username<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Username<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Password<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Password<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<IPv4<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &IPv4<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<IPv4<L>> for Ipv4Addr

fn dummy_with_rng<R: Rng + ?Sized>(_: &IPv4<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<IPv6<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &IPv6<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<IPv6<L>> for Ipv6Addr

fn dummy_with_rng<R: Rng + ?Sized>(_: &IPv6<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<IP<L>> for IpAddr

fn dummy_with_rng<R: Rng + ?Sized>(_: &IP<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<MACAddress<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &MACAddress<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Color<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Color<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<UserAgent<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &UserAgent<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<UserAgent<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &UserAgent<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Seniority<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Seniority<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Seniority<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Seniority<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Field<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Field<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Field<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Field<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Position<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Position<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Position<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Position<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Title<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Title<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Word<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Word<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Word<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Word<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Words<L>> for Vec<String>

fn dummy_with_rng<R: Rng + ?Sized>(c: &Words<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Sentence<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Sentence<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Sentences<L>> for Vec<String>

fn dummy_with_rng<R: Rng + ?Sized>(c: &Sentences<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Paragraph<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Paragraph<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Paragraphs<L>> for Vec<String>

fn dummy_with_rng<R: Rng + ?Sized>(c: &Paragraphs<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FirstName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &FirstName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<FirstName<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &FirstName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<LastName<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &LastName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<LastName<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &LastName<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Title<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Title<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Title<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Title<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Suffix<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Suffix<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Suffix<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Suffix<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<Name<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &Name<L>, rng: &mut R) -> Self

impl<L: Data + Copy> Dummy<NameWithTitle<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &NameWithTitle<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Digit<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &Digit<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<Digit<L>> for &str

fn dummy_with_rng<R: Rng + ?Sized>(_: &Digit<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<NumberWithFormat<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(c: &NumberWithFormat<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<PhoneNumber<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_: &PhoneNumber<L>, rng: &mut R) -> Self

impl<L: Data> Dummy<CellNumber<L>> for String

fn dummy_with_rng<R: Rng + ?Sized>(_c: &CellNumber<L>, rng: &mut R) -> Self

Implementors

impl<F> Dummy<F> for FormFactor

impl<F> Dummy<F> for OsFamily

impl<F> Dummy<F> for Browser

impl<F> Dummy<F> for DeviceInfo

impl<F> Dummy<F> for SuggestionRequest

impl<F> Dummy<F> for SuggestionResponse

impl<F> Dummy<F> for Suggestion