Fix elided lifetime Clippy errors

Author: johnpalsberg

flatgfa-py/src/lib.rs

@@ -41,7 +41,7 @@ impl Store {
     }
 
     /// Get the FlatGFA stored here.
-    fn view(&self) -> FlatGFA {
+    fn view(&self) -> FlatGFA<'_> {
         // TK It seems wasteful to check the type of store every time... and to construct
         // the view every time. It's probably possible to fix this with a self-reference,
         // e.g., with the `owning_ref` crate.

flatgfa/src/file.rs

@@ -182,7 +182,7 @@ fn read_toc_mut(data: &mut [u8]) -> (&mut Toc, &mut [u8]) {
 }
 
 /// Get a FlatGFA backed by the data in a byte buffer.
-pub fn view(data: &[u8]) -> flatgfa::FlatGFA {
+pub fn view(data: &[u8]) -> flatgfa::FlatGFA<'_> {
     let (toc, rest) = read_toc(data);
 
     let (header, rest) = slice_prefix(rest, toc.header);
@@ -216,7 +216,7 @@ pub fn view(data: &[u8]) -> flatgfa::FlatGFA {
 fn slice_vec_prefix<T: FromBytes + IntoBytes>(
     data: &mut [u8],
     size: Size,
-) -> (SliceVec<T>, &mut [u8]) {
+) -> (SliceVec<'_, T>, &mut [u8]) {
     let (prefix, rest) = <[T]>::mut_from_prefix_with_elems(data, size.capacity).unwrap();
     let vec = SliceVec::from_slice_len(prefix, size.len);
     (vec, rest)
@@ -252,13 +252,13 @@ fn slice_store<'a>(data: &'a mut [u8], toc: &Toc) -> flatgfa::FixedGFAStore<'a>
 }
 
 /// Get a mutable FlatGFA `SliceStore` backed by a byte buffer.
-pub fn view_store(data: &mut [u8]) -> flatgfa::FixedGFAStore {
+pub fn view_store(data: &mut [u8]) -> flatgfa::FixedGFAStore<'_> {
     let (toc, rest) = read_toc_mut(data);
     slice_store(rest, toc)
 }
 
 /// Initialize a buffer with an empty FlatGFA store.
-pub fn init(data: &mut [u8], toc: Toc) -> (&mut Toc, flatgfa::FixedGFAStore) {
+pub fn init(data: &mut [u8], toc: Toc) -> (&mut Toc, flatgfa::FixedGFAStore<'_>) {
     // Write the table of contents.
     assert!(data.len() == toc.size());
     toc.write_to_prefix(data).unwrap();

flatgfa/src/flatbed.rs

@@ -69,7 +69,7 @@ impl<'a, P: StoreFamily<'a>> BEDStore<'a, P> {
         self.entries.add(BEDEntry { name, start, end })
     }
 
-    pub fn as_ref(&self) -> FlatBED {
+    pub fn as_ref(&self) -> FlatBED<'_> {
         FlatBED {
             name_data: self.name_data.as_ref(),
             entries: self.entries.as_ref(),
@@ -108,7 +108,7 @@ pub type HeapBEDStore = BEDStore<'static, HeapFamily>;
 
 type ParseResult<T> = Result<T, &'static str>;
 type PartialParseResult<'a, T> = ParseResult<(T, &'a [u8])>;
-fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<T> {
+fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<'_, T> {
     match T::from_radix_10(s) {
         (_, 0) => Err("expected number"),
         (num, used) => Ok((num, &s[used..])),

flatgfa/src/flatgfa.rs

@@ -370,7 +370,7 @@ impl<'a> FlatGFA<'a> {
     ///
     /// A handle is a a forward or backward traversal of a specific segment. This method
     /// gets the sequence in the orientation specified by the handle.
-    pub fn get_seq_oriented(&self, handle: Handle) -> Sequence {
+    pub fn get_seq_oriented(&self, handle: Handle) -> Sequence<'_> {
         let seg = self.get_handle_seg(handle);
         let seq_data = self.seq_data[seg.seq].as_ref();
         Sequence::new(seq_data, handle.orient())
@@ -408,7 +408,7 @@ impl<'a> FlatGFA<'a> {
     }
 
     /// Look up a CIGAR alignment.
-    pub fn get_alignment(&self, overlap: Span<AlignOp>) -> Alignment {
+    pub fn get_alignment(&self, overlap: Span<AlignOp>) -> Alignment<'_> {
         Alignment {
             ops: &self.alignment[overlap],
         }
@@ -505,7 +505,7 @@ impl<'a, P: StoreFamily<'a>> GFAStore<'a, P> {
     }
 
     /// Borrow a FlatGFA view of this data store.
-    pub fn as_ref(&self) -> FlatGFA {
+    pub fn as_ref(&self) -> FlatGFA<'_> {
         FlatGFA {
             header: self.header.as_ref(),
             segs: self.segs.as_ref(),

flatgfa/src/gfaline.rs

@@ -34,7 +34,7 @@ pub struct Path<'a> {
 }
 
 /// Parse a single line of a GFA file.
-pub fn parse_line(line: &[u8]) -> LineResult {
+pub fn parse_line(line: &[u8]) -> LineResult<'_> {
     if line.len() < 2 || line[1] != b'\t' {
         return Err("expected marker and tab");
     }
@@ -49,20 +49,20 @@ pub fn parse_line(line: &[u8]) -> LineResult {
 }
 
 /// Parse a header line, which looks like `H <data>`.
-fn parse_header(line: &[u8]) -> LineResult {
+fn parse_header(line: &[u8]) -> LineResult<'_> {
     Ok(Line::Header(line))
 }
 
 /// Parse a segment line, which looks like `S <name> <seq> <data>`.
-fn parse_seg(line: &[u8]) -> LineResult {
+fn parse_seg(line: &[u8]) -> LineResult<'_> {
     let (name, rest) = parse_num(line)?;
     let rest = parse_byte(rest, b'\t')?;
     let (seq, data) = parse_field(rest)?;
     Ok(Line::Segment(Segment { name, seq, data }))
 }
 
 /// Parse a link line, which looks like `L <from> <+-> <to> <+-> <CIGAR>`.
-fn parse_link(line: &[u8]) -> LineResult {
+fn parse_link(line: &[u8]) -> LineResult<'_> {
     let (from_seg, rest) = parse_num(line)?;
     let rest = parse_byte(rest, b'\t')?;
     let (from_orient, rest) = parse_orient(rest)?;
@@ -85,7 +85,7 @@ fn parse_link(line: &[u8]) -> LineResult {
 }
 
 /// Parse a path line, which looks like `P <name> <steps> <*|CIGARs>`.
-fn parse_path(line: &[u8]) -> LineResult {
+fn parse_path(line: &[u8]) -> LineResult<'_> {
     let (name, rest) = parse_field(line)?;
     let (steps, rest) = parse_field(rest)?;
     let (overlaps, rest) = parse_maybe_overlap_list(rest)?;
@@ -100,7 +100,7 @@ fn parse_path(line: &[u8]) -> LineResult {
 }
 
 /// Parse a *possible* overlap list, which may be `*` (empty).
-pub fn parse_maybe_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>>> {
+pub fn parse_maybe_overlap_list(s: &[u8]) -> PartialParseResult<'_, Vec<Vec<AlignOp>>> {
     if s == b"*" {
         Ok((vec![], &s[1..]))
     } else {
@@ -111,7 +111,7 @@ pub fn parse_maybe_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>
 /// Parse a comma-separated list of CIGAR strings.
 ///
 /// TODO: This could be optimized to avoid accumulating into a vector.
-fn parse_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>>> {
+fn parse_overlap_list(s: &[u8]) -> PartialParseResult<'_, Vec<Vec<AlignOp>>> {
     let mut rest = s;
     let mut overlaps = vec![];
     while !rest.is_empty() {
@@ -126,7 +126,7 @@ fn parse_overlap_list(s: &[u8]) -> PartialParseResult<Vec<Vec<AlignOp>>> {
 }
 
 /// Consume a chunk of a string up to a given marker byte.
-fn parse_until(line: &[u8], marker: u8) -> PartialParseResult<&[u8]> {
+fn parse_until(line: &[u8], marker: u8) -> PartialParseResult<'_, &[u8]> {
     let end = memchr::memchr(marker, line).unwrap_or(line.len());
     let rest = if end == line.len() {
         &[]
@@ -137,7 +137,7 @@ fn parse_until(line: &[u8], marker: u8) -> PartialParseResult<&[u8]> {
 }
 
 /// Consume a string from the line, until a tab (or the end of the line).
-pub fn parse_field(line: &[u8]) -> PartialParseResult<&[u8]> {
+pub fn parse_field(line: &[u8]) -> PartialParseResult<'_, &[u8]> {
     parse_until(line, b'\t')
 }
 
@@ -150,15 +150,15 @@ fn parse_byte(s: &[u8], byte: u8) -> ParseResult<&[u8]> {
 }
 
 /// Parse a single integer.
-fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<T> {
+fn parse_num<T: FromRadix10>(s: &[u8]) -> PartialParseResult<'_, T> {
     match T::from_radix_10(s) {
         (_, 0) => Err("expected number"),
         (num, used) => Ok((num, &s[used..])),
     }
 }
 
 /// Parse a segment orientation (+ or -).
-fn parse_orient(line: &[u8]) -> PartialParseResult<Orientation> {
+fn parse_orient(line: &[u8]) -> PartialParseResult<'_, Orientation> {
     if line.is_empty() {
         return Err("expected orientation");
     }
@@ -171,7 +171,7 @@ fn parse_orient(line: &[u8]) -> PartialParseResult<Orientation> {
 }
 
 /// Parse a single CIGAR alignment operation (like `4D`).
-fn parse_align_op(s: &[u8]) -> PartialParseResult<AlignOp> {
+fn parse_align_op(s: &[u8]) -> PartialParseResult<'_, AlignOp> {
     let (len, rest) = parse_num::<u32>(s)?;
     let op = match rest[0] {
         b'M' => crate::flatgfa::AlignOpcode::Match,
@@ -186,7 +186,7 @@ fn parse_align_op(s: &[u8]) -> PartialParseResult<AlignOp> {
 /// Parse a complete CIGAR alignment string (like `3M2I`).
 ///
 /// TODO This could be optimized to avoid collecting into a vector.
-fn parse_align(s: &[u8]) -> PartialParseResult<Vec<AlignOp>> {
+fn parse_align(s: &[u8]) -> PartialParseResult<'_, Vec<AlignOp>> {
     let mut rest = s;
     let mut align = vec![];
     while !rest.is_empty() && rest[0].is_ascii_digit() {

flatgfa/src/memfile.rs

@@ -38,7 +38,7 @@ pub struct MemchrSplit<'a> {
 }
 
 impl MemchrSplit<'_> {
-    pub fn new(needle: u8, haystack: &[u8]) -> MemchrSplit {
+    pub fn new(needle: u8, haystack: &[u8]) -> MemchrSplit<'_> {
         MemchrSplit {
             needle,
             haystack,

flatgfa/src/packedseq.rs

@@ -314,7 +314,7 @@ impl PackedSeqStore {
         }
     }
 
-    pub fn as_ref(&self) -> PackedSeqView {
+    pub fn as_ref(&self) -> PackedSeqView<'_> {
         PackedSeqView {
             data: &self.data,
             high_nibble_end: self.high_nibble_end,

flatgfa/src/pool.rs

@@ -123,7 +123,7 @@ impl<T> Span<T> {
 /// access to the current set of objects (but not addition of new objects).
 pub trait Store<T: Clone> {
     /// Get a fixed-size view of the arena.
-    fn as_ref(&self) -> Pool<T>;
+    fn as_ref(&self) -> Pool<'_, T>;
 
     /// Add an item to the pool and get the new id.
     fn add(&mut self, item: T) -> Id<T>;
@@ -156,7 +156,7 @@ pub trait Store<T: Clone> {
 pub struct HeapStore<T>(Vec<T>);
 
 impl<T: Clone> Store<T> for HeapStore<T> {
-    fn as_ref(&self) -> Pool<T> {
+    fn as_ref(&self) -> Pool<'_, T> {
         Pool(&self.0)
     }
 
@@ -198,7 +198,7 @@ impl<T> Default for HeapStore<T> {
 pub struct FixedStore<'a, T>(SliceVec<'a, T>);
 
 impl<T: Clone> Store<T> for FixedStore<'_, T> {
-    fn as_ref(&self) -> Pool<T> {
+    fn as_ref(&self) -> Pool<'_, T> {
         Pool(&self.0)
     }