Struct AmbiAmino 

pub struct AmbiAmino(/* private fields */);

Ambiguous amino acid

Note that AmbiAmino always represents at least one possible amino acid; there is no such thing as an empty/null AmbiAmino. Also beware that ambi_amino.to_string().parse() is lossy because there are too many AmbiAminos to represent in a single character; anything without a standard character will be displayed as "X" but "X" is parsed as a maximally ambiguous AmbiAmino. However, the Debug implementation will exactly represent the AmbiAmino at the cost of being 1-25 characters long.

For details, see: https://en.wikipedia.org/wiki/FASTA_format#Sequence_representation

Beware that AmbiAmino’s order isn’t alphabetic.

Implementations

impl AmbiAmino

pub const Stop: Self = Self::STOP

Translation stop (alias for consistency with Amino::Stop)

pub const STOP: Self

Translation stop

pub const A: Self

Alanine

pub const B: Self

Aspartic acid (D) or asparagine (N)

pub const C: Self

Cysteine

pub const D: Self

Aspartic acid

pub const E: Self

Glutamic acid

pub const F: Self

Phenylalanine

pub const G: Self

Glycine

pub const H: Self

Histidine

pub const I: Self

Isoleucine

pub const J: Self

Leucine (L) or isoleucine (I)

pub const K: Self

Lysine

pub const L: Self

Leucine

pub const M: Self

Methionine

pub const N: Self

Asparagine

pub const O: Self

Pyrrolysine

pub const P: Self

Proline,

pub const Q: Self

Glutamine

pub const R: Self

Arginine

pub const S: Self

Serine

pub const T: Self

Threonine

pub const U: Self

Selenocysteine

pub const V: Self

Valine

pub const W: Self

Tryptophan

pub const Y: Self

Tyrosine

pub const Z: Self

Glutamic acid (E) or glutamine (Q)

pub const X: Self

Any amino acid

Note that this doesn’t perfectly round-trip. Any ambiguous amino that can’t be represented with a single-letter code will be displayed as “X” but “X” will be parsed as the X constant, which refers to a maximally ambiguous AmbiAmino.

pub fn to_bits(self) -> NonZeroU32

Cast AmbiAmino to NonZeroU32.

No particular representation is promised and the exact values are not part of stability guarantees.

pub fn to_str(self) -> &'static str

Return uppercase string representation

Note that anything without a single-character representation will result in "X". Use Debug formatting if you want a lossless representation.

Examples

use nucs::AmbiAmino;

assert_eq!(AmbiAmino::A.to_str(), "A");
assert_eq!(AmbiAmino::STOP.to_str(), "*");
assert_eq!((AmbiAmino::D | AmbiAmino::N).to_str(), "B");
assert_eq!((AmbiAmino::D | AmbiAmino::E).to_str(), "X");

pub const fn from_ascii(ascii: u8) -> Result<Self, ParseSymbolError>

Construct from ASCII representation

Errors

Returns ParseSymbolError if the given byte isn’t a letter or *.

Examples

use nucs::AmbiAmino;

assert_eq!(AmbiAmino::from_ascii(b'A'), Ok(AmbiAmino::A));
assert_eq!(AmbiAmino::from_ascii(b'*'), Ok(AmbiAmino::STOP));
assert_eq!(AmbiAmino::from_ascii(b'X'), Ok(AmbiAmino::X));
assert!(AmbiAmino::from_ascii(b'.').is_err());

pub fn to_ascii(self) -> u8

Return uppercase ASCII representation

See to_str for caveats.

Examples

use nucs::AmbiAmino;

assert_eq!(AmbiAmino::A.to_ascii(), b'A');
assert_eq!(AmbiAmino::STOP.to_ascii(), b'*');
assert_eq!((AmbiAmino::D | AmbiAmino::N).to_ascii(), b'B');
assert_eq!((AmbiAmino::D | AmbiAmino::E).to_ascii(), b'X');

pub const fn lit<const N: usize>(literal: &[u8; N]) -> [AmbiAmino; N]

Construct AmbiAmino array from literal without allocating.

Examples

use nucs::AmbiAmino;

let aas1 = AmbiAmino::lit(b"TOO*LONG");
// ...is shorthand for...
let aas2 = [
    AmbiAmino::T, AmbiAmino::O, AmbiAmino::O, AmbiAmino::STOP,
    AmbiAmino::L, AmbiAmino::O, AmbiAmino::N, AmbiAmino::G
];

assert_eq!(aas1, aas2);

Panics

This panics if the supplied literal isn’t valid. Whitespace is NOT allowed because the returned array must have the same length.

pub fn iter(self) -> AmbiAminoIter

Return iterator of Aminos that this ambiguous amino acid could be.

The iterator is guaranteed to return things in sorted order and without duplicates, and its contents are guaranteed to recompose into this AmbiAmino via BitOr.

Examples

use nucs::{AmbiAmino, Amino};

let aa = AmbiAmino::A | AmbiAmino::B | AmbiAmino::C;
assert!(aa.iter().eq(Amino::lit(b"ACDN")));

Trait Implementations

impl AsMut<AmbiAmino> for AmbiAmino

fn as_mut(&mut self) -> &mut AmbiAmino

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<AmbiAmino> for AmbiAmino

fn as_ref(&self) -> &AmbiAmino

Converts this type into a shared reference of the (usually inferred) input type.

impl BitOr<&AmbiAmino> for &Amino

type Output = AmbiAmino

The resulting type after applying the | operator.

fn bitor(self, rhs: &AmbiAmino) -> Self::Output

Performs the | operation.

impl BitOr<&Amino> for &AmbiAmino

type Output = AmbiAmino

The resulting type after applying the | operator.

fn bitor(self, rhs: &Amino) -> Self::Output

Performs the | operation.

impl BitOr<AmbiAmino> for Amino

type Output = AmbiAmino

The resulting type after applying the | operator.

fn bitor(self, rhs: AmbiAmino) -> Self::Output

Performs the | operation.

impl BitOr<Amino> for AmbiAmino

type Output = AmbiAmino

The resulting type after applying the | operator.

fn bitor(self, rhs: Amino) -> Self::Output

Performs the | operation.

impl BitOr for &AmbiAmino

type Output = AmbiAmino

The resulting type after applying the | operator.

fn bitor(self, rhs: &AmbiAmino) -> Self::Output

Performs the | operation.

impl BitOr for AmbiAmino

type Output = AmbiAmino

The resulting type after applying the | operator.

fn bitor(self, rhs: AmbiAmino) -> Self::Output

Performs the | operation.

impl BitOrAssign<&AmbiAmino> for AmbiAmino

fn bitor_assign(&mut self, rhs: &AmbiAmino)

Performs the |= operation.

impl BitOrAssign<&Amino> for AmbiAmino

fn bitor_assign(&mut self, rhs: &Amino)

Performs the |= operation.

impl BitOrAssign<Amino> for AmbiAmino

fn bitor_assign(&mut self, rhs: Amino)

Performs the |= operation.

impl BitOrAssign for AmbiAmino

fn bitor_assign(&mut self, rhs: AmbiAmino)

Performs the |= operation.

impl Clone for AmbiAmino

fn clone(&self) -> AmbiAmino

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AmbiAmino

Displays single-character code when possible, otherwise all possibilities.

Note that when falling back to bracket-enclosed possibilities, this doesn’t use ambiguity codes like B, J or Z.

use nucs::AmbiAmino;

assert_eq!(format!("{:?}", AmbiAmino::S), "S");
assert_eq!(format!("{:?}", AmbiAmino::L | AmbiAmino::I), "J");
assert_eq!(format!("{:?}", AmbiAmino::A | AmbiAmino::B), "[ADN]");
assert_eq!(format!("{:?}", AmbiAmino::X), "X");

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

Formats the value using the given formatter.

impl Default for AmbiAmino

fn default() -> AmbiAmino

Returns the “default value” for a type.

impl Display for AmbiAmino

Displays a single-character code, falling back to X.

Examples

use nucs::AmbiAmino;

assert_eq!(AmbiAmino::S.to_string(), "S");
assert_eq!((AmbiAmino::L | AmbiAmino::I).to_string(), "J");
assert_eq!((AmbiAmino::A | AmbiAmino::B).to_string(), "X");
assert_eq!(AmbiAmino::X.to_string(), "X");
// Note that despite the same representation they're not actually the same:
assert_ne!(AmbiAmino::A | AmbiAmino::B, AmbiAmino::X);

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

Formats the value using the given formatter.

impl From<Amino> for AmbiAmino

fn from(amino: Amino) -> Self

Converts to this type from the input type.

impl FromStr for AmbiAmino

type Err = ParseSymbolError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for AmbiAmino

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 IntoIterator for &AmbiAmino

type IntoIter = AmbiAminoIter

Which kind of iterator are we turning this into?

type Item = Amino

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for AmbiAmino

type IntoIter = AmbiAminoIter

Which kind of iterator are we turning this into?

type Item = Amino

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for AmbiAmino

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

fn eq(&self, other: &AmbiAmino) -> 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 PartialEq<Amino> for AmbiAmino

fn eq(&self, other: &Amino) -> 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 PartialEq for AmbiAmino

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

fn partial_cmp(&self, other: &AmbiAmino) -> 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 PartialOrd<Amino> for AmbiAmino

fn partial_cmp(&self, other: &Amino) -> 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 PartialOrd for AmbiAmino

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

type Concrete = Amino

Concrete symbols, i.e. Nuc or Amino

type Ambiguous = AmbiAmino

Ambiguous symbols, i.e. AmbiNuc or AmbiAmino

fn to_str(self) -> &'static str

Return uppercase string representation

fn from_ascii(ascii: u8) -> Result<Self, ParseSymbolError>

Construct from (case-insensitive) ASCII representation

fn to_ascii(self) -> u8

Return uppercase ASCII representation

fn lit<const N: usize>(literal: &[u8; N]) -> [Self; N]

Construct array from literal without allocating.

impl TryFrom<AmbiAmino> for Amino

type Error = AmbiAmino

The type returned in the event of a conversion error.

fn try_from(amino: AmbiAmino) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for AmbiAmino

impl Eq for AmbiAmino

impl StructuralPartialEq for AmbiAmino