Struct Seq

pub struct Seq<A: Codec> { /* private fields */ }

A arbitrary length sequence of bit-packed symbols

Stored on the heap

Implementations

impl Seq<Iupac>

pub fn contains(&self, rhs: &SeqSlice<Iupac>) -> bool

impl<A: Codec> Seq<A>

pub fn new() -> Self

pub fn trim_u8(v: &[u8]) -> Result<Self, ParseBioError>

Trim leading and trailing characters that don’t match bases/symbols

let seq = b"NNNNAGAATGATGGGGGGGGGGGCGNNNNNNNNNNN";
let trimmed: Seq<Dna> = Seq::trim_u8(seq).unwrap();
assert_eq!(trimmed, dna!("AGAATGATGGGGGGGGGGGCG"));

Errors

Will return an UnrecognisedBase error for non-leading or non-trailing end bases, just as TryFrom<&[u8]> would.

pub fn with_capacity(len: usize) -> Self

pub fn bit_and(self, rhs: Seq<A>) -> Seq<A>

pub fn bit_or(self, rhs: Seq<A>) -> Seq<A>

pub fn push(&mut self, item: A)

pub fn clear(&mut self)

pub fn truncate(&mut self, len: usize)

Truncate a sequence

let mut seq: Seq<Dna> = dna!("CCCCC").into();
seq.truncate(2);
assert_eq!(&seq, dna!("CC"));

pub fn prepend(&mut self, other: &SeqSlice<A>)

Prepend a slice

let mut seq: Seq<Dna> = dna!("CCCCC").into();
seq.prepend(dna!("TTTT"));
assert_eq!(&seq, dna!("TTTTCCCCC"));

pub fn append(&mut self, other: &SeqSlice<A>)

Append a slice

let mut seq: Seq<Dna> = dna!("CCCCC").into();
seq.append(dna!("TTTT"));
assert_eq!(&seq, dna!("CCCCCTTTT"));

pub fn insert(&mut self, index: usize, other: &SeqSlice<A>)

Insert a slice into a sequence

let mut seq: Seq<Dna> = dna!("AAAAA").into();
seq.insert(3, dna!("TTTT"));
assert_eq!(&seq, dna!("AAATTTTAA"));

Panics

Panics if index out of bounds

pub fn remove<R: RangeBounds<usize>>(&mut self, range: R)

Remove a region of a sequence

let mut seq: Seq<Dna> = dna!("ACGTACGT").into();
seq.remove(2..5);
assert_eq!(&seq, dna!("ACCGT"));

pub fn extend<I: IntoIterator<Item = A>>(&mut self, iter: I)

pub fn from_raw(len: usize, bits: &[usize]) -> Option<Self>

Experimental Decode sequence from raw usize array. This requires the exact length of the target sequence to be known.

let ints: [usize; 2] = [0b0101010101010101010101010101010111111111111111111111111111111111, 0b11100100];
let seq: Option<Seq<Dna>> = Seq::from_raw(36, &ints);
assert_eq!(seq.unwrap(), dna!("TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCACGT"));

pub fn into_raw(&self) -> &[usize]

Experimental Access raw sequence data as &[usize]

let seq: Seq<Dna> = dna!("TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCACGT").into();
let ints: Vec<usize> = seq.into_raw().iter().copied().collect();
assert_eq!(ints[0], 0b0101010101010101010101010101010111111111111111111111111111111111);
assert_eq!(ints[1], 0b11100100); // ACGT

Methods from Deref<Target = SeqSlice<A>>

pub fn chain( self: &'a SeqSlice<A>, second: &'a SeqSlice<A>, ) -> Chain<SeqIter<'a, A>, SeqIter<'a, A>>

pub fn iter(&'a self) -> SeqIter<'a, A>

pub fn kmers<const K: usize>(&self) -> KmerIter<'_, A, K>

Iterate over sliding windows of length K

pub fn rev_iter(&self) -> RevIter<'_, A>

Iterate over the sequence in reverse order

pub fn windows(&self, width: usize) -> SeqChunks<'_, A>

Iterate over the sequence in overlapping windows of a specified width

use bio_seq::prelude::*;

let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let windows: Vec<String> = seq.windows(3).map(String::from).collect();
assert_eq!(windows, vec!["ACT", "CTG", "TGA", "GAT", "ATC", "TCG"]);

pub fn chunks(&self, width: usize) -> SeqChunks<'_, A>

Iterate over the sequence in non-overlapping chunks of a specified width

The last incomplete chunk will be excluded if the sequence length is not divisible by the specified width.

use bio_seq::prelude::*;

let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let chunks: Vec<Seq<Dna>> = seq.chunks(3).collect();
assert_eq!(chunks, vec![dna!("ACT"), dna!("GAT")]);

pub fn nth(&self, i: usize) -> A

unsafely index into the ith position of a sequence

pub fn len(&self) -> usize

pub fn get(&self, i: usize) -> Option<A>

Get the ith element of a Seq. Returns None if index out of range.

pub fn is_empty(&self) -> bool

Trait Implementations

impl<A: Codec> AsRef<SeqSlice<A>> for Seq<A>

A Seq can be borrowed as a SeqSlice through generic constraints.

fn count_bases<S: AsRef<SeqSlice<Dna>>>(s: S) -> usize {
   s.as_ref().len()
}

let seq: Seq<Dna> = dna!("CATCGATCGATC").into();
let count = count_bases(seq); // the AsRef implementation allows us to directly pass a Seq
assert_eq!(count, 12);

fn as_ref(&self) -> &SeqSlice<A>

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

impl<A: Codec> Borrow<SeqSlice<A>> for &Seq<A>

fn borrow(&self) -> &SeqSlice<A>

Immutably borrows from an owned value.

impl<A: Codec> Borrow<SeqSlice<A>> for Seq<A>

Borrow a Seq<A> as a SeqSlice<A>.

The Borrow trait to is used to obtain a reference to a SeqSlice from a Seq, allowing it to be used wherever a SeqSlice is expected.

use std::collections::HashMap;
use bio_seq::prelude::*;

let reference = dna!("ACGTTCGCATGCTACGACGATC");

let mut table: HashMap<Seq<Dna>, usize> = HashMap::new();

// Associate some kind of count with sequences as keys:
table.insert(dna!("ACGTT").into(), 1);
table.insert(dna!("ACACCCCC").into(), 0);

// The query is a short window in the reference `Seq`
let query: &SeqSlice<Dna> = &reference[..5];

if let Some(value) = table.get(query) {
       // `SeqSlice` implements `Display`
       println!("{query}: {value}");
}

fn borrow(&self) -> &SeqSlice<A>

Immutably borrows from an owned value.

impl<A: Codec> Clone for Seq<A>

Creates a deep copy of the sequence.

#[macro_use]
let mut seq1: Seq<Dna> = dna!("CATCGATCGATC").into();
let seq2: Seq<Dna> = seq1.clone();

seq1.push(Dna::A);
assert_ne!(seq1, seq2);

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Codec + ComplementMut> Complement for Seq<A>

fn to_comp(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + ComplementMut> ComplementMut for Seq<A>

fn comp(&mut self)

impl<A: Debug + Codec> Debug for Seq<A>

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

Formats the value using the given formatter.

impl<A: Codec> Default for Seq<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Codec> Deref for Seq<A>

Automatic dereferencing of Seq<A> to SeqSlice<A>.

fn count_bases(s: &SeqSlice<Dna>) -> usize {
   s.len()
}

let seq: Seq<Dna> = dna!("CATCGATCGATC").into();
let count = count_bases(&seq);
assert_eq!(count, 12);

type Target = SeqSlice<A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, A: Codec> Deserialize<'de> for Seq<A>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Codec> Display for Seq<A>

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

Formats the value using the given formatter.

impl<A: Codec> Extend<A> for Seq<A>

fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A: Codec> From<&BitSlice> for Seq<A>

Unstable construct a Seq from a bitslice. This may change in the future.

fn from(bs: &BitSlice<usize, Lsb0>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<&Seq<A>> for String

fn from(seq: &Seq<A>) -> Self

Converts to this type from the input type.

impl<A, B: Codec, const N: usize, const W: usize> From<&SeqArray<A, N, W>> for Seq<B>

where A: Into<B> + Codec,

fn from(slice: &SeqArray<A, N, W>) -> Self

Converts to this type from the input type.

impl<A, B: Codec> From<&SeqSlice<A>> for Seq<B>

where A: Into<B> + Codec,

fn from(slice: &SeqSlice<A>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<&Vec<A>> for Seq<A>

fn from(vec: &Vec<A>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<BitVec> for Seq<A>

Unstable construct a Seq from a bitvec. This may change in the future.

fn from(bv: BitVec<usize, Lsb0>) -> Self

Converts to this type from the input type.

impl<A: Codec, const K: usize> From<Kmer<A, K>> for Seq<A>

fn from(kmer: Kmer<A, K, usize>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<Seq<A>> for String

fn from(seq: Seq<A>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<Seq<A>> for usize

fn from(slice: Seq<A>) -> usize

Converts to this type from the input type.

impl<A, B: Codec, const N: usize, const W: usize> From<SeqArray<A, N, W>> for Seq<B>

where A: Into<B> + Codec,

fn from(slice: SeqArray<A, N, W>) -> Self

Converts to this type from the input type.

impl From<Vec<usize>> for Seq<Dna>

fn from(vec: Vec<usize>) -> Self

Converts to this type from the input type.

impl<A: Codec> FromIterator<A> for Seq<A>

fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> Self

Creates a value from an iterator.

impl<A: Codec> FromStr for Seq<A>

type Err = ParseBioError

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<A: Codec> Hash for Seq<A>

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<'a, A: Codec> IntoIterator for &'a Seq<A>

type Item = A

The type of the elements being iterated over.

type IntoIter = SeqIter<'a, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Codec + MaskableMut> Maskable for Seq<A>

fn to_mask(&self) -> <Self as ToOwned>::Owned

fn to_unmask(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + MaskableMut> MaskableMut for Seq<A>

fn mask(&mut self)

fn unmask(&mut self)

impl<A: Ord + Codec> Ord for Seq<A>

fn cmp(&self, other: &Seq<A>) -> 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<A: Codec> PartialEq<&Seq<A>> for Seq<A>

fn eq(&self, other: &&Seq<A>) -> 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<A: Codec> PartialEq<&SeqSlice<A>> for Seq<A>

fn eq(&self, other: &&SeqSlice<A>) -> 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<A: Codec> PartialEq<Seq<A>> for &Seq<A>

fn eq(&self, other: &Seq<A>) -> 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<A: Codec> PartialEq<Seq<A>> for &SeqSlice<A>

fn eq(&self, other: &Seq<A>) -> 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<A: Codec, const K: usize> PartialEq<Seq<A>> for Kmer<A, K>

fn eq(&self, seq: &Seq<A>) -> 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<A: Codec> PartialEq<Seq<A>> for SeqSlice<A>

fn eq(&self, other: &Seq<A>) -> 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<A: Codec> PartialEq<SeqSlice<A>> for Seq<A>

fn eq(&self, other: &SeqSlice<A>) -> 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<A: PartialEq + Codec> PartialEq for Seq<A>

fn eq(&self, other: &Seq<A>) -> 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<A: PartialOrd + Codec> PartialOrd for Seq<A>

fn partial_cmp(&self, other: &Seq<A>) -> 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<A: Codec> Reverse for Seq<A>

fn to_rev(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + ComplementMut> ReverseComplement for Seq<A>

where Seq<A>: ComplementMut + ReverseMut,

fn to_revcomp(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + ComplementMut> ReverseComplementMut for Seq<A>

where Seq<A>: ComplementMut + ReverseMut,

fn revcomp(&mut self)

Reverse complement a sequence in place

impl<A: Codec> ReverseMut for Seq<A>

fn rev(&mut self)

Reverse sequence in place

impl<A: Codec> Serialize for Seq<A>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Codec> TryFrom<&[u8]> for Seq<A>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(v: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec> TryFrom<&String> for Seq<A>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(s: &String) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec> TryFrom<&str> for Seq<A>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec, const K: usize> TryFrom<Seq<A>> for Kmer<A, K>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(seq: Seq<A>) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec> TryFrom<String> for Seq<A>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec> TryFrom<Vec<u8>> for Seq<A>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(v: Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Eq + Codec> Eq for Seq<A>

impl<A: Codec> StructuralPartialEq for Seq<A>