Enum AmbiNuc 

#[repr(u8)]
pub enum AmbiNuc {
    A = 1,
    C = 2,
    G = 4,
    T = 8,
    R = 5,
    Y = 10,
    M = 3,
    K = 12,
    W = 9,
    S = 6,
    B = 14,
    D = 13,
    H = 11,
    V = 7,
    N = 15,
}

Ambiguous nucleotide

Note that AmbiNuc always represents at least one possible nucleotide; there is no such thing as an empty/null AmbiNuc.

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

Beware that AmbiNuc’s order isn’t alphabetic.

Variants

A = 1

Adenine

C = 2

Cytosine

G = 4

Guanine

T = 8

Thymine

R = 5

A/G: puRine

Y = 10

C/T: pYrimidines

M = 3

A/C: aMino groups

K = 12

G/T: Ketones

W = 9

A/T: Weak interaction

S = 6

C/G: Strong interaction

B = 14

C/G/T: Not A (B comes after A)

D = 13

A/G/T: Not C (D comes after C)

H = 11

A/C/T: Not G (H comes after G)

V = 7

A/C/G: Not T (V comes after U/T)

N = 15

A/C/G/T: Nucleic acid

Implementations

impl AmbiNuc

pub const ALL: [Self; 15]

All AmbiNucs sorted in ascending order

pub const fn complement(self) -> Self

Return ambiguous nucleotide containing complements for each potential value.

use nucs::AmbiNuc;

assert_eq!(AmbiNuc::A.complement(), AmbiNuc::T);
assert_eq!(AmbiNuc::C.complement(), AmbiNuc::G);
assert_eq!(AmbiNuc::G.complement(), AmbiNuc::C);
assert_eq!(AmbiNuc::T.complement(), AmbiNuc::A);

// D -> A|G|T -> T|C|A -> H
assert_eq!(AmbiNuc::D.complement(), AmbiNuc::H);

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

Return uppercase string representation

Examples

use nucs::AmbiNuc;

assert_eq!(AmbiNuc::A.to_str(), "A");
assert_eq!(AmbiNuc::N.to_str(), "N");

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

Construct from ASCII representation

Errors

Returns ParseSymbolError if the given byte isn’t A, B, C, D, G, H, K, M, N, R, S, T, V, W or Y (case-insensitve).

Examples

use nucs::AmbiNuc;

assert_eq!(AmbiNuc::from_ascii(b'A'), Ok(AmbiNuc::A));
assert!(AmbiNuc::from_ascii(b'E').is_err());

pub const fn to_ascii(self) -> u8

Return uppercase ASCII representation

Examples

use nucs::AmbiNuc;

assert_eq!(AmbiNuc::A.to_ascii(), b'A');
assert_eq!(AmbiNuc::N.to_ascii(), b'N');

pub fn iter(self) -> Copied<Iter<'static, Nuc>>

Return iterator of Nucs that this ambiguous nucleotide could be.

The iterator will be consistent with AmbiNuc::expansions. The same effect can be achieved with AmbiNuc’s implementation of IntoIterator.

Examples

use nucs::{AmbiNuc, Nuc};

assert!(AmbiNuc::B.iter().eq(Nuc::lit(b"CGT")));

assert_eq!(Vec::from_iter(AmbiNuc::B), AmbiNuc::B.expansions());

pub const fn expansions(self) -> &'static [Nuc]

Return slice of Nucs that this ambiguous nucleotide could be.

The slice will be non-empty, deduplicated, sorted, and its contents are guaranteed to recompose into this AmbiNuc via BitOr.

Examples

use nucs::{AmbiNuc, Nuc};

assert_eq!(AmbiNuc::B.expansions(), Nuc::lit(b"CGT"));
assert_eq!(Nuc::C | Nuc::G | Nuc::T, AmbiNuc::B);

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

Construct AmbiNuc array from literal without allocating.

Examples

use nucs::AmbiNuc;

let dna1 = AmbiNuc::lit(b"NASTYGRAM");
// ...is shorthand for...
use AmbiNuc::{N, A, S, T, Y, G, R, M};
let dna2 = [N, A, S, T, Y, G, R, A, M];

assert_eq!(dna1, dna2);

Panics

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

Trait Implementations

impl AsMut<AmbiNuc> for AmbiNuc

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

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

impl AsRef<AmbiNuc> for AmbiNuc

fn as_ref(&self) -> &AmbiNuc

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

impl BitOr<&AmbiNuc> for &Nuc

type Output = AmbiNuc

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&Nuc> for &AmbiNuc

type Output = AmbiNuc

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<AmbiNuc> for Nuc

type Output = AmbiNuc

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Nuc> for AmbiNuc

type Output = AmbiNuc

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for &AmbiNuc

type Output = AmbiNuc

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for AmbiNuc

type Output = AmbiNuc

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<&AmbiNuc> for AmbiNuc

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

Performs the |= operation.

impl BitOrAssign<&Nuc> for AmbiNuc

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

Performs the |= operation.

impl BitOrAssign<Nuc> for AmbiNuc

fn bitor_assign(&mut self, rhs: Nuc)

Performs the |= operation.

impl BitOrAssign for AmbiNuc

fn bitor_assign(&mut self, rhs: AmbiNuc)

Performs the |= operation.

impl Clone for AmbiNuc

fn clone(&self) -> AmbiNuc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AmbiNuc

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

Formats the value using the given formatter.

impl Default for AmbiNuc

fn default() -> AmbiNuc

Returns the “default value” for a type.

impl Display for AmbiNuc

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

Formats the value using the given formatter.

impl From<Nuc> for AmbiNuc

fn from(nuc: Nuc) -> Self

Converts to this type from the input type.

impl FromStr for AmbiNuc

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 AmbiNuc

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 &AmbiNuc

type IntoIter = Copied<Iter<'static, Nuc>>

Which kind of iterator are we turning this into?

type Item = Nuc

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for AmbiNuc

type IntoIter = Copied<Iter<'static, Nuc>>

Which kind of iterator are we turning this into?

type Item = Nuc

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Nucleotide for AmbiNuc

const ALL: &[Self]

All possible nucleotides in ascending order

type Amino = AmbiAmino

Amino acid; either Amino or AmbiAmino

fn complement(self) -> Self

Return this nucleotide’s complement.

fn translate<G: GeneticCode>(codon: [Self; 3], genetic_code: G) -> Self::Amino

Translate a codon into an amino acid

impl Ord for AmbiNuc

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

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

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

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

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

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

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

type Concrete = Nuc

Concrete symbols, i.e. Nuc or Amino

type Ambiguous = AmbiNuc

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<AmbiNuc> for Nuc

type Error = AmbiNuc

The type returned in the event of a conversion error.

fn try_from(nuc: AmbiNuc) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for AmbiNuc

impl Eq for AmbiNuc

impl StructuralPartialEq for AmbiNuc