Enum Group 

pub enum Group {
    IA,
    IIA,
    // some variants omitted
}

Each group in the periodic table

Variants

IA

Alkali metals

IIA

Alkaline earths

Implementations

impl Group

pub const fn group_name(&self) -> Option<&'static str>

Returns the group’s trivial name, if any.

use mendeleev::Group;
assert_eq!(Group::IA.group_name(), Some("Alkali metals"));
assert_eq!(Group::VIIIA.group_name(), Some("Noble gases"));
assert_eq!(Group::VIIIB8.group_name(), None);

impl Group

pub const fn group_number(&self) -> u32

Returns the group’s number in the periodic table.

use mendeleev::Group;
assert_eq!(Group::IA.group_number(), 1);
assert_eq!(Group::VIIIA.group_number(), 18);

impl Group

pub const fn group_symbol(&self) -> &'static str

Returns the group’s symbol in the CAS system

use mendeleev::Group;
assert_eq!(Group::IA.group_symbol(), "IA");
assert_eq!(Group::VIIIA.group_symbol(), "VIIIA");
assert_eq!(Group::VIIIB8.group_symbol(), "VIIIB");

Examples found in repository

examples/print_all_elements.rs (line 60)

fn main() {
    let columns: Vec<(&str, Box<dyn Fn(&Element) -> String>)> = vec![
        (
            "Number",
            Box::new(|e: &Element| e.atomic_number().to_string()),
        ),
        ("Symbol", Box::new(|e: &Element| e.symbol().to_string())),
        (
            "Name      ",
            Box::new(|e: &Element| format!("{:<10}", e.name())),
        ),
        (
            "Year",
            Box::new(|e: &Element| e.year_discovered().to_string()),
        ),
        (
            "CPK color",
            Box::new(|e: &Element| {
                format!(
                    "{:<10}",
                    e.cpk_color()
                        .map(|c| c.to_string())
                        .unwrap_or("".to_string()),
                )
            }),
        ),
        (
            "Jmol color",
            Box::new(|e: &Element| {
                format!(
                    "{:<10}",
                    e.jmol_color()
                        .map(|c| c.to_string())
                        .unwrap_or("".to_string()),
                )
            }),
        ),
        (
            "Atomic Weight",
            Box::new(|e: &Element| format!("{:<10}", e.atomic_weight().to_string())),
        ),
        (
            "Atomic Radius",
            Box::new(|e: &Element| {
                format!(
                    "{:10}",
                    e.atomic_radius()
                        .map(|r| r.to_string())
                        .unwrap_or("".to_string())
                )
            }),
        ),
        ("Period", Box::new(|e: &Element| e.period().to_string())),
        (
            "Group",
            Box::new(|e: &Element| {
                format!("{:<10}", e.group().map(|g| g.group_symbol()).unwrap_or(""))
            }),
        ),
    ];
    println!(
        "{}",
        columns
            .iter()
            .map(|(name, _)| *name)
            .collect::<Vec<_>>()
            .join("\t")
    );
    for element in Element::list() {
        println!(
            "{}",
            columns
                .iter()
                .map(|(_, prop)| prop(&element))
                .collect::<Vec<_>>()
                .join("\t")
        );
    }
}

impl Group

pub const fn list() -> &'static [Self]

Slice containing all groups, ordered by group number

use mendeleev::Group;
use mendeleev::N_GROUPS;

for n in 1..=N_GROUPS {
    assert_eq!(Group::list()[n - 1].group_number() as usize, n);
}

Examples found in repository

examples/print_periodic_table.rs (line 6)

fn main() {
    for period in 1..=N_PERIODS {
        for group in Group::list() {
            let element = Element::list()
                .iter()
                .find(|e| e.period() == period && e.group() == Some(*group));
            match element {
                Some(element) => print!("{:<4}", element.symbol()),
                None => print!("    "),
            }
        }
        println!();
    }
    println!();
    for period in 6..=7 {
        print!("        ");
        for element in Element::list()
            .iter()
            .filter(|el| el.period() == period && el.group().is_none())
        {
            print!("{:<4}", element.symbol());
        }
        println!();
    }
}

pub fn iter() -> impl Iterator<Item = Self> + Clone

Returns an iterator that yields all the groups by value, ordered by group number

use mendeleev::Group;

assert_eq!(Group::iter().next(), Some(Group::IA));

Trait Implementations

impl Clone for Group

fn clone(&self) -> Group

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Group

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

Formats the value using the given formatter.

impl Hash for Group

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Group

fn cmp(&self, other: &Group) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Group

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Group

fn partial_cmp(&self, other: &Group) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Group

impl Eq for Group

impl StructuralPartialEq for Group