Struct petname::Petnames

pub struct Petnames<'a> {
    pub adjectives: Words<'a>,
    pub adverbs: Words<'a>,
    pub nouns: Words<'a>,
}

Word lists and the logic to combine them into petnames.

A petname with n words will contain, in order:

• n - 2 adverbs when n >= 2, otherwise 0 adverbs.
• 1 adjective when n >= 2, otherwise 0 adjectives.
• 1 noun when n >= 1, otherwise 0 nouns.

Fields

adjectives: Words<'a>

adverbs: Words<'a>

nouns: Words<'a>

Implementations

impl<'a> Petnames<'a>

pub fn small() -> Self

Constructs a new Petnames from the small word lists.

pub fn medium() -> Self

Constructs a new Petnames from the medium word lists.

pub fn large() -> Self

Constructs a new Petnames from the large word lists.

pub fn new(adjectives: &'a str, adverbs: &'a str, nouns: &'a str) -> Self

Constructs a new Petnames from the given word lists.

The words are extracted from the given strings by splitting on whitespace.

pub fn retain<F>(&mut self, predicate: F)

where F: FnMut(&str) -> bool,

Keep words matching a predicate.

Examples

let mut petnames = petname::Petnames::default();
petnames.retain(|s| s.starts_with("h"));
assert!(petnames.generate_one(2, ".").unwrap().starts_with('h'));

This is a convenience wrapper that applies the same predicate to the adjectives, adverbs, and nouns lists.

pub fn cardinality(&self, words: u8) -> u128

Calculate the cardinality of this Petnames.

If this is low, names may be repeated by the generator with a higher frequency than your use-case may allow.

This can saturate. If the total possible combinations of words exceeds u128::MAX then this will return u128::MAX.

Trait Implementations

impl<'a> Clone for Petnames<'a>

fn clone(&self) -> Petnames<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Petnames<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Petnames<'a>

fn default() -> Self

Constructs a new Petnames from the default (medium) word lists.

impl<'a> From<Petnames<'a>> for Alliterations<'a>

fn from(petnames: Petnames<'a>) -> Self

Converts to this type from the input type.

impl<'a> Generator<'a> for Petnames<'a>

fn generate( &self, rng: &mut dyn RngCore, words: u8, separator: &str ) -> Option<String>

Generate a new petname.

fn generate_one(&self, words: u8, separator: &str) -> Option<String>

Generate a single new petname.

fn iter( &'a self, rng: &'a mut dyn RngCore, words: u8, separator: &str ) -> Box<dyn Iterator<Item = String> + 'a>

where Self: Sized,

Iterator yielding petnames.

impl<'a> PartialEq for Petnames<'a>

fn eq(&self, other: &Petnames<'a>) -> 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<'a> Eq for Petnames<'a>

impl<'a> StructuralPartialEq for Petnames<'a>