Enum Element 

pub enum Element {
    H,
    He,
    Li,
    // some variants omitted
}

Each of the known chemical elements

Variants

H

Hydrogen

He

Helium

Li

Lithium

Implementations

impl Element

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

Slice containing all elements, ordered by atomic number

use mendeleev::Element;
use mendeleev::N_ELEMENTS;

for n in 1..=N_ELEMENTS {
    assert_eq!(Element::list()[n - 1].atomic_number() as usize, n);
}

Examples found in repository

examples/print_electronic_configuration.rs (line 5)

fn main() {
    for element in Element::list() {
        println!(
            "{}:\t{}",
            element.symbol(),
            element.electronic_configuration()
        );
    }
}

examples/print_isotope_abundance.rs (line 5)

fn main() {
    for element in Element::list() {
        print!("{}: ", element.name());
        let isotope_count = Isotope::list()
            .iter()
            .filter(|isotope| &isotope.element() == element)
            .flat_map(|isotope| {
                let abundance = isotope.natural_abundance()?;
                print!("{}: {}, ", isotope.display_with_superscript(), abundance);
                Some(())
            })
            .count();
        if isotope_count == 0 {
            print!("No naturally occurring isotopes");
        }
        println!();
    }
}

examples/print_periodic_table.rs (line 7)

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!();
    }
}

examples/print_all_elements.rs (line 72)

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")
        );
    }
}

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

Returns an iterator that yields all the elements by value, ordered by atomic number

use mendeleev::Element;

assert_eq!(Element::iter().next(), Some(Element::H));

impl Element

pub const fn atomic_number(&self) -> u32

Returns the element’s atomic number, i.e., the number of protons in its nucleus.

use mendeleev::Element;
assert_eq!(Element::H.atomic_number(), 1);
assert_eq!(Element::Og.atomic_number(), 118);

Examples found in repository

examples/print_all_elements.rs (line 8)

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 Element

pub const fn atomic_radius(&self) -> Option<Picometer>

Returns the element’s empirically measured atomic radius, if available.

use mendeleev::{Element, Picometer};
assert_eq!(Element::H.atomic_radius(), Some(Picometer(25.0)));

Examples found in repository

examples/print_all_elements.rs (line 50)

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 Element

pub const fn atomic_weight(&self) -> AtomicWeight

Returns the element’s Standard Atomic Weight, if applicable, or its mass number otherwise.

use mendeleev::{Element, AtomicWeight};

assert_eq!(Element::H.atomic_weight(),
AtomicWeight::Interval{range: 1.0078..=1.0082, conventional: 1.008});
assert_eq!(Element::Og.atomic_weight(), AtomicWeight::MassNumber{number: 294});

Examples found in repository

examples/print_all_elements.rs (line 43)

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 Element

pub const fn cpk_color(&self) -> Option<Color>

Returns the color for the element in the CPK convention.

use mendeleev::{Element, Color};

assert_eq!(Element::H.cpk_color(), Some(Color{r: 255, g: 255, b: 255}));
assert_eq!(Element::Og.cpk_color(), None);
assert_eq!(Element::Au.cpk_color(), Some(Color{r: 218, g: 165, b: 32}));

Examples found in repository

examples/print_all_elements.rs (line 24)

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 Element

pub const fn group(&self) -> Option<Group>

Returns the element’s group in the periodic table, if any.

use mendeleev::{Element, Group};
assert_eq!(Element::H.group(), Some(Group::IA));
assert_eq!(Element::Og.group(), Some(Group::VIIIA));
assert_eq!(Element::U.group(), None);

Examples found in repository

examples/print_periodic_table.rs (line 9)

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!();
    }
}

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 Element

pub const fn jmol_color(&self) -> Option<Color>

Returns the color for the element in the jmol software

use mendeleev::{Element, Color};

assert_eq!(Element::H.jmol_color(), Some(Color{r: 255, g: 255, b: 255}));
assert_eq!(Element::Og.jmol_color(), None);
assert_eq!(Element::Au.jmol_color(), Some(Color{r: 255, g: 209, b: 35}));

Examples found in repository

examples/print_all_elements.rs (line 35)

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 Element

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

Returns the name of the element in English.

use mendeleev::Element;
assert_eq!(Element::H.name(), "Hydrogen");

Examples found in repository

examples/print_isotope_abundance.rs (line 6)

fn main() {
    for element in Element::list() {
        print!("{}: ", element.name());
        let isotope_count = Isotope::list()
            .iter()
            .filter(|isotope| &isotope.element() == element)
            .flat_map(|isotope| {
                let abundance = isotope.natural_abundance()?;
                print!("{}: {}, ", isotope.display_with_superscript(), abundance);
                Some(())
            })
            .count();
        if isotope_count == 0 {
            print!("No naturally occurring isotopes");
        }
        println!();
    }
}

examples/print_all_elements.rs (line 13)

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 Element

pub const fn period(&self) -> u32

Returns the element’s period number in the periodic table.

use mendeleev::Element;
assert_eq!(Element::H.period(), 1);
assert_eq!(Element::Og.period(), 7);

Examples found in repository

examples/print_periodic_table.rs (line 9)

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!();
    }
}

examples/print_all_elements.rs (line 56)

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 Element

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

Returns the symbol for the element

use mendeleev::Element;
assert_eq!(Element::H.symbol(), "H");

Examples found in repository

examples/print_electronic_configuration.rs (line 8)

fn main() {
    for element in Element::list() {
        println!(
            "{}:\t{}",
            element.symbol(),
            element.electronic_configuration()
        );
    }
}

examples/print_periodic_table.rs (line 11)

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!();
    }
}

examples/print_all_elements.rs (line 10)

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 Element

pub const fn year_discovered(&self) -> YearDiscovered

The year in which the element was discovered, if known.

use mendeleev::{Element, YearDiscovered};

assert_eq!(Element::H.year_discovered(), YearDiscovered::Known(1766));
assert_eq!(Element::Og.year_discovered(), YearDiscovered::Known(2002));
assert_eq!(Element::Au.year_discovered(), YearDiscovered::Ancient);

Examples found in repository

examples/print_all_elements.rs (line 17)

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 Element

pub const fn melting_point(&self) -> Option<Kelvin>

Returns the element’s melting point, if known.

For some elements that do not melt at atmospheric pressure, the value is given for triple point pressure.

For elements that have multiple allotropes, one of them was chosen arbitrarily for the return value.

use mendeleev::{Element, Kelvin};
assert_eq!(Element::H.melting_point(), Some(Kelvin(13.99)));
// Carbon allotropes have no melting point at standard pressure
assert_eq!(Element::C.melting_point(), None);
// White phosphorus
assert_eq!(Element::P.melting_point(), Some(Kelvin(317.3)));
assert_eq!(Element::Og.melting_point(), None);

impl Element

pub const fn boiling_point(&self) -> Option<Kelvin>

Returns the element’s boiling point, if known.

For elements that have multiple allotropes, one of them was chosen arbitrarily for the return value.

use mendeleev::{Element, Kelvin};
assert_eq!(Element::H.boiling_point(), Some(Kelvin(20.271)));
// Graphite (sublimation point)
assert_eq!(Element::C.boiling_point(), Some(Kelvin(4098.15)));
// White phosphorus
assert_eq!(Element::P.boiling_point(), Some(Kelvin(553.65)));
assert_eq!(Element::Og.boiling_point(), None);

impl Element

pub const fn fusion_heat(&self) -> Option<KiloJoulePerMole>

Returns the element’s fusion heat, if known.

use mendeleev::{Element, KiloJoulePerMole};
assert_eq!(Element::H.fusion_heat(), Some(KiloJoulePerMole(0.117)));
assert_eq!(Element::Og.fusion_heat(), None);

impl Element

pub const fn evaporation_heat(&self) -> Option<KiloJoulePerMole>

Returns the element’s evaporation heat, if known.

use mendeleev::{Element, KiloJoulePerMole};
assert_eq!(Element::H.evaporation_heat(), Some(KiloJoulePerMole(0.904)));

impl Element

pub const fn electronic_configuration(&self) -> ElectronicConfiguration

Returns the element’s electronic configuration.

use mendeleev::{Element, SubshellLabel};

let configuration = Element::Li.electronic_configuration();
assert_eq!(configuration.noble_gas, Some(Element::He));
assert_eq!(configuration.valence_subshells[0].shell_number, 2);
assert_eq!(configuration.valence_subshells[0].subshell_label, SubshellLabel::S);
assert_eq!(configuration.valence_subshells[0].number_of_electrons, 1);

Examples found in repository

examples/print_electronic_configuration.rs (line 9)

fn main() {
    for element in Element::list() {
        println!(
            "{}:\t{}",
            element.symbol(),
            element.electronic_configuration()
        );
    }
}

impl Element

pub const fn discoverers(&self) -> Option<&'static [&'static str]>

Returns the persons and/or institutions involved in the discovery of the element, if known.

use mendeleev::Element;

assert_eq!(Element::H.discoverers(), Some(["Henry Cavendish"].as_slice()));
assert_eq!(Element::He.discoverers(), Some(["Sir William Ramsey", "Nils Langet", "P.T.Cleve"].as_slice()));
assert_eq!(Element::Og.discoverers(), Some(["Joint Institute for Nuclear Research"].as_slice()));
assert_eq!(Element::Au.discoverers(), None);

impl Element

pub const fn discovery_location(&self) -> Option<&'static [&'static str]>

Returns the location (country, in most cases) where the element was discovered, if known. There can be multiple locations if it was an international effort or if multiple teams discovered or isolated the element independently.

use mendeleev::Element;

assert_eq!(Element::H.discovery_location(), Some(["England"].as_slice()));
assert_eq!(Element::He.discovery_location(), Some(["Scotland", "Sweden"].as_slice()));
assert_eq!(Element::Og.discovery_location(), Some(["Russia"].as_slice()));
assert_eq!(Element::Au.discovery_location(), None);

impl Element

pub const fn oxidation_states( &self, category: OxidationStateCategory, ) -> &'static [i8]

Returns the element’s oxidation states for the given category.

Example

use mendeleev::{Element, OxidationStateCategory::{Main, Extended, All}};

assert_eq!(Element::N.oxidation_states(Main), [-3, 3, 5]);
assert_eq!(Element::N.oxidation_states(Extended), [-2, -1, 0, 1, 2, 4]);
assert_eq!(Element::N.oxidation_states(All), [-3, -2, -1, 0, 1, 2, 3, 4, 5]);

impl Element

pub const fn density(&self) -> Option<GramPerCubicCentimeter>

Returns the element’s density in its most common form, if available.

use mendeleev::{Element, GramPerCubicCentimeter};
assert_eq!(Element::H.density(), Some(GramPerCubicCentimeter(0.00008988)));

impl Element

pub const fn electron_affinity(&self) -> Option<Electronvolt>

Returns the element’s electron affinity, if available.

use mendeleev::{Element, Electronvolt};
assert_eq!(Element::H.electron_affinity(), Some(Electronvolt(0.754)));

impl Element

pub const fn ionization_energy(&self) -> Option<Electronvolt>

Returns the element’s ionization energy, if available.

use mendeleev::{Element, Electronvolt};
assert_eq!(Element::H.ionization_energy(), Some(Electronvolt(13.598)));

Trait Implementations

impl Clone for Element

fn clone(&self) -> Element

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Element

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

Formats the value using the given formatter.

impl Hash for Element

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 Element

fn cmp(&self, other: &Element) -> 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 Element

fn eq(&self, other: &Element) -> 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 Element

fn partial_cmp(&self, other: &Element) -> 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 Element

impl Eq for Element

impl StructuralPartialEq for Element