diff --git a/core/src/dictionary/data_element.rs b/core/src/dictionary/data_element.rs
index a467519c8..e94646aac 100644
--- a/core/src/dictionary/data_element.rs
+++ b/core/src/dictionary/data_element.rs
@@ -152,8 +152,6 @@ enum ParseSelectorErrorInner {
     ParseKey,
     /// invalid item index, should be an unsigned integer
     ParseItemIndex,
-    /// intermediate selector step should select a sequence item
-    ParseItem,
     /// last selector step should select a plain tag
     ParseLeaf,
 }
diff --git a/core/src/header.rs b/core/src/header.rs
index bcc254b68..1d43c09bb 100644
--- a/core/src/header.rs
+++ b/core/src/header.rs
@@ -1217,7 +1217,7 @@ impl PartialOrd<Length> for Length {
     }
 }
 
-impl ::std::ops::Add<Length> for Length {
+impl std::ops::Add<Length> for Length {
     type Output = Self;
 
     fn add(self, rhs: Length) -> Self::Output {
@@ -1235,7 +1235,7 @@ impl ::std::ops::Add<Length> for Length {
     }
 }
 
-impl ::std::ops::Add<i32> for Length {
+impl std::ops::Add<i32> for Length {
     type Output = Self;
 
     fn add(self, rhs: i32) -> Self::Output {
@@ -1357,11 +1357,7 @@ impl fmt::Display for Length {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        dicom_value,
-        value::{InMemFragment, PixelFragmentSequence},
-        DicomValue,
-    };
+    use crate::{dicom_value, value::PixelFragmentSequence, DicomValue};
 
     #[test]
     fn to_clean_string() {
diff --git a/core/src/lib.rs b/core/src/lib.rs
index f8fd8cf72..56b4cb3e5 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -145,7 +145,6 @@ macro_rules! dicom_value {
 
 #[cfg(test)]
 mod tests {
-    use crate::dicom_value;
     use crate::value::PrimitiveValue;
     use smallvec::smallvec;
 
diff --git a/core/src/value/deserialize.rs b/core/src/value/deserialize.rs
index 38ceb40af..d32f8beab 100644
--- a/core/src/value/deserialize.rs
+++ b/core/src/value/deserialize.rs
@@ -460,7 +460,6 @@ pub fn parse_datetime_partial(buf: &[u8]) -> Result<DicomDateTime> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use chrono::{FixedOffset, NaiveDate, NaiveTime};
 
     #[test]
     fn test_parse_date() {
diff --git a/core/src/value/mod.rs b/core/src/value/mod.rs
index 8423b4dc2..8aa21ae1f 100644
--- a/core/src/value/mod.rs
+++ b/core/src/value/mod.rs
@@ -1086,7 +1086,6 @@ impl<P> DicomValueType for PixelFragmentSequence<P> {
 mod tests {
     use super::*;
     use crate::dicom_value;
-    use crate::header::EmptyObject;
     use smallvec::smallvec;
 
     #[test]
diff --git a/core/src/value/partial.rs b/core/src/value/partial.rs
index 209980f4b..53c22720b 100644
--- a/core/src/value/partial.rs
+++ b/core/src/value/partial.rs
@@ -987,10 +987,8 @@ impl PartialOrd for PreciseDateTime {
 
 #[cfg(test)]
 mod tests {
-    use crate::value::range::AsRange;
-
     use super::*;
-    use chrono::{NaiveDateTime, TimeZone};
+    use chrono::TimeZone;
 
     #[test]
     fn test_dicom_date() {
diff --git a/encoding/src/decode/explicit_be.rs b/encoding/src/decode/explicit_be.rs
index ce59640fc..3237cebef 100644
--- a/encoding/src/decode/explicit_be.rs
+++ b/encoding/src/decode/explicit_be.rs
@@ -1,8 +1,11 @@
 //! Explicit VR Big Endian syntax transfer implementation.
 
 use crate::decode::basic::BigEndianBasicDecoder;
-use crate::decode::*;
-use crate::decode::{BasicDecode, Decode, DecodeFrom};
+use crate::decode::{
+    BadSequenceHeaderSnafu, BasicDecode, Decode, DecodeFrom, ReadHeaderTagSnafu,
+    ReadItemHeaderSnafu, ReadItemLengthSnafu, ReadLengthSnafu, ReadReservedSnafu, ReadTagSnafu,
+    ReadVrSnafu, Result,
+};
 use byteordered::byteorder::{BigEndian, ByteOrder};
 use dicom_core::header::{DataElementHeader, Length, SequenceItemHeader};
 use dicom_core::{Tag, VR};
@@ -65,7 +68,9 @@ impl Decode for ExplicitVRBigEndianDecoder {
             }
             _ => {
                 // read 2 bytes for the data length
-                source.read_exact(&mut buf[0..2]).context(ReadLengthSnafu)?;
+                source
+                    .read_exact(&mut buf[0..2])
+                    .context(ReadItemLengthSnafu)?;
                 bytes_read = 8;
                 u32::from(BigEndian::read_u16(&buf[0..2]))
             }
diff --git a/encoding/src/decode/explicit_le.rs b/encoding/src/decode/explicit_le.rs
index ab821b1b2..aa6830e57 100644
--- a/encoding/src/decode/explicit_le.rs
+++ b/encoding/src/decode/explicit_le.rs
@@ -1,7 +1,11 @@
 //! Explicit VR Little Endian syntax transfer implementation
 
 use crate::decode::basic::LittleEndianBasicDecoder;
-use crate::decode::*;
+use crate::decode::{
+    BadSequenceHeaderSnafu, BasicDecode, Decode, DecodeFrom, ReadHeaderTagSnafu,
+    ReadItemHeaderSnafu, ReadItemLengthSnafu, ReadLengthSnafu, ReadReservedSnafu, ReadTagSnafu,
+    ReadVrSnafu, Result,
+};
 use byteordered::byteorder::{ByteOrder, LittleEndian};
 use dicom_core::header::{DataElementHeader, Length, SequenceItemHeader};
 use dicom_core::{Tag, VR};
diff --git a/encoding/src/decode/implicit_le.rs b/encoding/src/decode/implicit_le.rs
index fb6675211..af6bf9dfc 100644
--- a/encoding/src/decode/implicit_le.rs
+++ b/encoding/src/decode/implicit_le.rs
@@ -1,7 +1,11 @@
 //! Implicit VR Big Endian syntax transfer implementation
 
 use crate::decode::basic::LittleEndianBasicDecoder;
-use crate::decode::*;
+use crate::decode::{
+    BadSequenceHeaderSnafu, BasicDecode, DecodeFrom, ReadHeaderTagSnafu, ReadLengthSnafu,
+    ReadTagSnafu, Result,
+};
+use crate::Decode;
 use byteordered::byteorder::{ByteOrder, LittleEndian};
 use dicom_core::dictionary::{DataDictionary, DataDictionaryEntry};
 use dicom_core::header::{DataElementHeader, Length, SequenceItemHeader};
diff --git a/encoding/src/decode/mod.rs b/encoding/src/decode/mod.rs
index aa7e00aaf..3dc7db730 100644
--- a/encoding/src/decode/mod.rs
+++ b/encoding/src/decode/mod.rs
@@ -90,13 +90,13 @@ pub trait BasicDecode {
     fn endianness(&self) -> Endianness;
 
     /// Decode an unsigned short value from the given source.
-    fn decode_us<S>(&self, source: S) -> std::io::Result<u16>
+    fn decode_us<S>(&self, source: S) -> io::Result<u16>
     where
         S: Read;
 
     /// Decode a sequence of unsigned shorts value from the given source
     /// into the given destination.
-    fn decode_us_into<S>(&self, mut source: S, dst: &mut [u16]) -> std::io::Result<()>
+    fn decode_us_into<S>(&self, mut source: S, dst: &mut [u16]) -> io::Result<()>
     where
         S: Read,
     {
@@ -108,13 +108,13 @@ pub trait BasicDecode {
     }
 
     /// Decode an unsigned long value from the given source.
-    fn decode_ul<S>(&self, source: S) -> std::io::Result<u32>
+    fn decode_ul<S>(&self, source: S) -> io::Result<u32>
     where
         S: Read;
 
     /// Decode a sequence of unsigned long values from the given source
     /// into the given destination.
-    fn decode_ul_into<S>(&self, mut source: S, dst: &mut [u32]) -> std::io::Result<()>
+    fn decode_ul_into<S>(&self, mut source: S, dst: &mut [u32]) -> io::Result<()>
     where
         S: Read,
     {
@@ -126,13 +126,13 @@ pub trait BasicDecode {
     }
 
     /// Decode an unsigned very long value from the given source.
-    fn decode_uv<S>(&self, source: S) -> std::io::Result<u64>
+    fn decode_uv<S>(&self, source: S) -> io::Result<u64>
     where
         S: Read;
 
     /// Decode a sequence of unsigned very long values from the given source
     /// into the given destination.
-    fn decode_uv_into<S>(&self, mut source: S, dst: &mut [u64]) -> std::io::Result<()>
+    fn decode_uv_into<S>(&self, mut source: S, dst: &mut [u64]) -> io::Result<()>
     where
         S: Read,
     {
@@ -144,13 +144,13 @@ pub trait BasicDecode {
     }
 
     /// Decode a signed short value from the given source.
-    fn decode_ss<S>(&self, source: S) -> std::io::Result<i16>
+    fn decode_ss<S>(&self, source: S) -> io::Result<i16>
     where
         S: Read;
 
     /// Decode a sequence of signed short values from the given source
     /// into the given destination.
-    fn decode_ss_into<S>(&self, mut source: S, dst: &mut [i16]) -> std::io::Result<()>
+    fn decode_ss_into<S>(&self, mut source: S, dst: &mut [i16]) -> io::Result<()>
     where
         S: Read,
     {
@@ -162,13 +162,13 @@ pub trait BasicDecode {
     }
 
     /// Decode a signed long value from the given source.
-    fn decode_sl<S>(&self, source: S) -> std::io::Result<i32>
+    fn decode_sl<S>(&self, source: S) -> io::Result<i32>
     where
         S: Read;
 
     /// Decode a sequence of signed long values from the given source
     /// into the given destination.
-    fn decode_sl_into<S>(&self, mut source: S, dst: &mut [i32]) -> std::io::Result<()>
+    fn decode_sl_into<S>(&self, mut source: S, dst: &mut [i32]) -> io::Result<()>
     where
         S: Read,
     {
@@ -180,13 +180,13 @@ pub trait BasicDecode {
     }
 
     /// Decode a signed very long value from the given source.
-    fn decode_sv<S>(&self, source: S) -> std::io::Result<i64>
+    fn decode_sv<S>(&self, source: S) -> io::Result<i64>
     where
         S: Read;
 
     /// Decode a sequence of signed very long values from the given source
     /// into the given destination.
-    fn decode_sv_into<S>(&self, mut source: S, dst: &mut [i64]) -> std::io::Result<()>
+    fn decode_sv_into<S>(&self, mut source: S, dst: &mut [i64]) -> io::Result<()>
     where
         S: Read,
     {
@@ -198,13 +198,13 @@ pub trait BasicDecode {
     }
 
     /// Decode a single precision float value from the given source.
-    fn decode_fl<S>(&self, source: S) -> std::io::Result<f32>
+    fn decode_fl<S>(&self, source: S) -> io::Result<f32>
     where
         S: Read;
 
     /// Decode a sequence of single precision float values from the given source
     /// into the given destination.
-    fn decode_fl_into<S>(&self, mut source: S, dst: &mut [f32]) -> std::io::Result<()>
+    fn decode_fl_into<S>(&self, mut source: S, dst: &mut [f32]) -> io::Result<()>
     where
         S: Read,
     {
@@ -216,13 +216,13 @@ pub trait BasicDecode {
     }
 
     /// Decode a double precision float value from the given source.
-    fn decode_fd<S>(&self, source: S) -> std::io::Result<f64>
+    fn decode_fd<S>(&self, source: S) -> io::Result<f64>
     where
         S: Read;
 
     /// Decode a sequence of double precision float values from the given source
     /// into the given destination.
-    fn decode_fd_into<S>(&self, mut source: S, dst: &mut [f64]) -> std::io::Result<()>
+    fn decode_fd_into<S>(&self, mut source: S, dst: &mut [f64]) -> io::Result<()>
     where
         S: Read,
     {
@@ -234,7 +234,7 @@ pub trait BasicDecode {
     }
 
     /// Decode a DICOM attribute tag from the given source.
-    fn decode_tag<S>(&self, mut source: S) -> std::io::Result<Tag>
+    fn decode_tag<S>(&self, mut source: S) -> io::Result<Tag>
     where
         S: Read,
     {
@@ -252,119 +252,119 @@ where
         (**self).endianness()
     }
 
-    fn decode_us<S>(&self, source: S) -> std::io::Result<u16>
+    fn decode_us<S>(&self, source: S) -> io::Result<u16>
     where
         S: Read,
     {
         (**self).decode_us(source)
     }
 
-    fn decode_us_into<S>(&self, source: S, dst: &mut [u16]) -> std::io::Result<()>
+    fn decode_us_into<S>(&self, source: S, dst: &mut [u16]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_us_into(source, dst)
     }
 
-    fn decode_ul<S>(&self, source: S) -> std::io::Result<u32>
+    fn decode_ul<S>(&self, source: S) -> io::Result<u32>
     where
         S: Read,
     {
         (**self).decode_ul(source)
     }
 
-    fn decode_ul_into<S>(&self, source: S, dst: &mut [u32]) -> std::io::Result<()>
+    fn decode_ul_into<S>(&self, source: S, dst: &mut [u32]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_ul_into(source, dst)
     }
 
-    fn decode_uv<S>(&self, source: S) -> std::io::Result<u64>
+    fn decode_uv<S>(&self, source: S) -> io::Result<u64>
     where
         S: Read,
     {
         (**self).decode_uv(source)
     }
 
-    fn decode_uv_into<S>(&self, source: S, dst: &mut [u64]) -> std::io::Result<()>
+    fn decode_uv_into<S>(&self, source: S, dst: &mut [u64]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_uv_into(source, dst)
     }
 
-    fn decode_ss<S>(&self, source: S) -> std::io::Result<i16>
+    fn decode_ss<S>(&self, source: S) -> io::Result<i16>
     where
         S: Read,
     {
         (**self).decode_ss(source)
     }
 
-    fn decode_ss_into<S>(&self, source: S, dst: &mut [i16]) -> std::io::Result<()>
+    fn decode_ss_into<S>(&self, source: S, dst: &mut [i16]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_ss_into(source, dst)
     }
 
-    fn decode_sl<S>(&self, source: S) -> std::io::Result<i32>
+    fn decode_sl<S>(&self, source: S) -> io::Result<i32>
     where
         S: Read,
     {
         (**self).decode_sl(source)
     }
 
-    fn decode_sl_into<S>(&self, source: S, dst: &mut [i32]) -> std::io::Result<()>
+    fn decode_sl_into<S>(&self, source: S, dst: &mut [i32]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_sl_into(source, dst)
     }
 
-    fn decode_sv<S>(&self, source: S) -> std::io::Result<i64>
+    fn decode_sv<S>(&self, source: S) -> io::Result<i64>
     where
         S: Read,
     {
         (**self).decode_sv(source)
     }
 
-    fn decode_sv_into<S>(&self, source: S, dst: &mut [i64]) -> std::io::Result<()>
+    fn decode_sv_into<S>(&self, source: S, dst: &mut [i64]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_sv_into(source, dst)
     }
 
-    fn decode_fl<S>(&self, source: S) -> std::io::Result<f32>
+    fn decode_fl<S>(&self, source: S) -> io::Result<f32>
     where
         S: Read,
     {
         (**self).decode_fl(source)
     }
 
-    fn decode_fl_into<S>(&self, source: S, dst: &mut [f32]) -> std::io::Result<()>
+    fn decode_fl_into<S>(&self, source: S, dst: &mut [f32]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_fl_into(source, dst)
     }
 
-    fn decode_fd<S>(&self, source: S) -> std::io::Result<f64>
+    fn decode_fd<S>(&self, source: S) -> io::Result<f64>
     where
         S: Read,
     {
         (**self).decode_fd(source)
     }
 
-    fn decode_fd_into<S>(&self, source: S, dst: &mut [f64]) -> std::io::Result<()>
+    fn decode_fd_into<S>(&self, source: S, dst: &mut [f64]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_fd_into(source, dst)
     }
 
-    fn decode_tag<S>(&self, source: S) -> std::io::Result<Tag>
+    fn decode_tag<S>(&self, source: S) -> io::Result<Tag>
     where
         S: Read,
     {
@@ -380,119 +380,119 @@ where
         (**self).endianness()
     }
 
-    fn decode_us<S>(&self, source: S) -> std::io::Result<u16>
+    fn decode_us<S>(&self, source: S) -> io::Result<u16>
     where
         S: Read,
     {
         (**self).decode_us(source)
     }
 
-    fn decode_us_into<S>(&self, source: S, dst: &mut [u16]) -> std::io::Result<()>
+    fn decode_us_into<S>(&self, source: S, dst: &mut [u16]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_us_into(source, dst)
     }
 
-    fn decode_ul<S>(&self, source: S) -> std::io::Result<u32>
+    fn decode_ul<S>(&self, source: S) -> io::Result<u32>
     where
         S: Read,
     {
         (**self).decode_ul(source)
     }
 
-    fn decode_ul_into<S>(&self, source: S, dst: &mut [u32]) -> std::io::Result<()>
+    fn decode_ul_into<S>(&self, source: S, dst: &mut [u32]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_ul_into(source, dst)
     }
 
-    fn decode_uv<S>(&self, source: S) -> std::io::Result<u64>
+    fn decode_uv<S>(&self, source: S) -> io::Result<u64>
     where
         S: Read,
     {
         (**self).decode_uv(source)
     }
 
-    fn decode_uv_into<S>(&self, source: S, dst: &mut [u64]) -> std::io::Result<()>
+    fn decode_uv_into<S>(&self, source: S, dst: &mut [u64]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_uv_into(source, dst)
     }
 
-    fn decode_ss<S>(&self, source: S) -> std::io::Result<i16>
+    fn decode_ss<S>(&self, source: S) -> io::Result<i16>
     where
         S: Read,
     {
         (**self).decode_ss(source)
     }
 
-    fn decode_ss_into<S>(&self, source: S, dst: &mut [i16]) -> std::io::Result<()>
+    fn decode_ss_into<S>(&self, source: S, dst: &mut [i16]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_ss_into(source, dst)
     }
 
-    fn decode_sl<S>(&self, source: S) -> std::io::Result<i32>
+    fn decode_sl<S>(&self, source: S) -> io::Result<i32>
     where
         S: Read,
     {
         (**self).decode_sl(source)
     }
 
-    fn decode_sl_into<S>(&self, source: S, dst: &mut [i32]) -> std::io::Result<()>
+    fn decode_sl_into<S>(&self, source: S, dst: &mut [i32]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_sl_into(source, dst)
     }
 
-    fn decode_sv<S>(&self, source: S) -> std::io::Result<i64>
+    fn decode_sv<S>(&self, source: S) -> io::Result<i64>
     where
         S: Read,
     {
         (**self).decode_sv(source)
     }
 
-    fn decode_sv_into<S>(&self, source: S, dst: &mut [i64]) -> std::io::Result<()>
+    fn decode_sv_into<S>(&self, source: S, dst: &mut [i64]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_sv_into(source, dst)
     }
 
-    fn decode_fl<S>(&self, source: S) -> std::io::Result<f32>
+    fn decode_fl<S>(&self, source: S) -> io::Result<f32>
     where
         S: Read,
     {
         (**self).decode_fl(source)
     }
 
-    fn decode_fl_into<S>(&self, source: S, dst: &mut [f32]) -> std::io::Result<()>
+    fn decode_fl_into<S>(&self, source: S, dst: &mut [f32]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_fl_into(source, dst)
     }
 
-    fn decode_fd<S>(&self, source: S) -> std::io::Result<f64>
+    fn decode_fd<S>(&self, source: S) -> io::Result<f64>
     where
         S: Read,
     {
         (**self).decode_fd(source)
     }
 
-    fn decode_fd_into<S>(&self, source: S, dst: &mut [f64]) -> std::io::Result<()>
+    fn decode_fd_into<S>(&self, source: S, dst: &mut [f64]) -> io::Result<()>
     where
         S: Read,
     {
         (**self).decode_fd_into(source, dst)
     }
 
-    fn decode_tag<S>(&self, source: S) -> std::io::Result<Tag>
+    fn decode_tag<S>(&self, source: S) -> io::Result<Tag>
     where
         S: Read,
     {
diff --git a/encoding/src/encode/explicit_be.rs b/encoding/src/encode/explicit_be.rs
index d8f3b1fec..a85e2d974 100644
--- a/encoding/src/encode/explicit_be.rs
+++ b/encoding/src/encode/explicit_be.rs
@@ -1,15 +1,18 @@
 //! Explicit VR Big Endian syntax transfer implementation.
 
 use crate::encode::basic::BigEndianBasicEncoder;
-use crate::encode::*;
+use crate::encode::{
+    BasicEncode, Encode, Result, WriteHeaderSnafu, WriteItemDelimiterSnafu, WriteItemHeaderSnafu,
+    WriteOffsetTableSnafu, WriteSequenceDelimiterSnafu, WriteTagSnafu,
+};
+
 use byteordered::byteorder::{BigEndian, ByteOrder};
 use byteordered::Endianness;
 use dicom_core::header::{DataElementHeader, HasLength, Header};
 use dicom_core::{PrimitiveValue, Tag, VR};
+use snafu::ResultExt;
 use std::io::{self, Write};
 
-type Result<T> = std::result::Result<T, Error>;
-
 /// A concrete encoder for the transfer syntax ExplicitVRBigEndian
 #[derive(Debug, Default, Clone)]
 pub struct ExplicitVRBigEndianEncoder {
diff --git a/encoding/src/encode/explicit_le.rs b/encoding/src/encode/explicit_le.rs
index 03f1a7081..dff50e12d 100644
--- a/encoding/src/encode/explicit_le.rs
+++ b/encoding/src/encode/explicit_le.rs
@@ -1,7 +1,10 @@
 //! Explicit VR Little Endian syntax transfer implementation
 
 use crate::encode::basic::LittleEndianBasicEncoder;
-use crate::encode::*;
+use crate::encode::{
+    BasicEncode, Encode, Result, WriteHeaderSnafu, WriteItemDelimiterSnafu, WriteItemHeaderSnafu,
+    WriteOffsetTableSnafu, WriteSequenceDelimiterSnafu, WriteTagSnafu,
+};
 use byteordered::byteorder::{ByteOrder, LittleEndian};
 use byteordered::Endianness;
 use dicom_core::header::{DataElementHeader, HasLength, Header};
diff --git a/encoding/src/encode/implicit_le.rs b/encoding/src/encode/implicit_le.rs
index 8b6a2b433..dd3fa9def 100644
--- a/encoding/src/encode/implicit_le.rs
+++ b/encoding/src/encode/implicit_le.rs
@@ -1,11 +1,15 @@
 //! Implicit VR Big Endian syntax transfer implementation
 
 use crate::encode::basic::LittleEndianBasicEncoder;
-use crate::encode::*;
+use crate::encode::{
+    BasicEncode, Encode, Result, WriteHeaderSnafu, WriteItemDelimiterSnafu, WriteItemHeaderSnafu,
+    WriteOffsetTableSnafu, WriteSequenceDelimiterSnafu, WriteTagSnafu,
+};
 use byteordered::byteorder::{ByteOrder, LittleEndian};
 use byteordered::Endianness;
 use dicom_core::header::{DataElementHeader, HasLength, Header};
 use dicom_core::{PrimitiveValue, Tag};
+use snafu::ResultExt;
 use std::io::{self, Write};
 
 /// A concrete encoder for the transfer syntax ImplicitVRLittleEndian
diff --git a/encoding/src/encode/mod.rs b/encoding/src/encode/mod.rs
index f7a474c0a..9718b16b4 100644
--- a/encoding/src/encode/mod.rs
+++ b/encoding/src/encode/mod.rs
@@ -144,12 +144,12 @@ pub trait BasicEncode {
     #[inline]
     fn with_encoder<T, F1, F2>(&self, f_le: F1, f_be: F2) -> T
     where
-        F1: FnOnce(self::basic::LittleEndianBasicEncoder) -> T,
-        F2: FnOnce(self::basic::BigEndianBasicEncoder) -> T,
+        F1: FnOnce(basic::LittleEndianBasicEncoder) -> T,
+        F2: FnOnce(basic::BigEndianBasicEncoder) -> T,
     {
         match self.endianness() {
-            Endianness::Little => f_le(self::basic::LittleEndianBasicEncoder),
-            Endianness::Big => f_be(self::basic::BigEndianBasicEncoder),
+            Endianness::Little => f_le(basic::LittleEndianBasicEncoder),
+            Endianness::Big => f_be(basic::BigEndianBasicEncoder),
         }
     }
 
diff --git a/json/src/ser/mod.rs b/json/src/ser/mod.rs
index f9a9fd1e4..f8a1d552b 100644
--- a/json/src/ser/mod.rs
+++ b/json/src/ser/mod.rs
@@ -304,8 +304,8 @@ mod tests {
     use pretty_assertions::assert_eq;
 
     use dicom_core::value::DataSetSequence;
-    use dicom_core::{dicom_value, value::DicomDate, Tag};
-    use dicom_core::{Length, VR};
+    use dicom_core::Length;
+    use dicom_core::{dicom_value, value::DicomDate};
     use dicom_dictionary_std::tags;
     use serde_json::json;
 
diff --git a/json/src/ser/value.rs b/json/src/ser/value.rs
index e06ec8d5c..5da391190 100644
--- a/json/src/ser/value.rs
+++ b/json/src/ser/value.rs
@@ -194,7 +194,6 @@ impl<'a> From<&'a str> for PersonNameDef<'a> {
 mod tests {
     use dicom_core::dicom_value;
     use dicom_core::value::DicomDate;
-    use dicom_core::PrimitiveValue;
     use pretty_assertions::assert_eq;
     use serde_json::json;
     use serde_json::Value;
diff --git a/object/src/lib.rs b/object/src/lib.rs
index c4be065f0..22dd28917 100644
--- a/object/src/lib.rs
+++ b/object/src/lib.rs
@@ -139,8 +139,6 @@ pub mod meta;
 pub mod ops;
 pub mod tokens;
 
-mod util;
-
 pub use crate::file::{from_reader, open_file, OpenFileOptions};
 pub use crate::mem::InMemDicomObject;
 pub use crate::meta::{FileMetaTable, FileMetaTableBuilder};
diff --git a/object/src/mem.rs b/object/src/mem.rs
index fc32f6404..4db47d570 100644
--- a/object/src/mem.rs
+++ b/object/src/mem.rs
@@ -872,7 +872,7 @@ where
         &self,
         selector: impl Into<AttributeSelector>,
     ) -> Result<&Value<InMemDicomObject<D>, InMemFragment>, AtAccessError> {
-        let selector = selector.into();
+        let selector: AttributeSelector = selector.into();
 
         let mut obj = self;
         for (i, step) in selector.iter().enumerate() {
@@ -1719,23 +1719,19 @@ fn even_len(l: u32) -> u32 {
 mod tests {
 
     use super::*;
-    use crate::AtAccessError;
-    use crate::{meta::FileMetaTableBuilder, open_file};
+    use crate::open_file;
     use byteordered::Endianness;
     use dicom_core::chrono::FixedOffset;
-    use dicom_core::ops::AttributeSelector;
-    use dicom_core::value::{DicomDate, DicomDateTime, DicomTime, PrimitiveValue};
+    use dicom_core::value::{DicomDate, DicomDateTime, DicomTime};
     use dicom_core::{
         dicom_value,
-        header::{DataElementHeader, Length, VR},
-        ops::{AttributeAction, AttributeOp},
+        header::DataElementHeader,
     };
     use dicom_encoding::{
         decode::{basic::BasicDecoder, implicit_le::ImplicitVRLittleEndianDecoder},
         encode::{implicit_le::ImplicitVRLittleEndianEncoder, EncoderFor},
     };
-    use dicom_parser::{dataset::IntoTokens, StatefulDecoder};
-    use tempfile;
+    use dicom_parser::StatefulDecoder;
 
     fn assert_obj_eq<D>(obj1: &InMemDicomObject<D>, obj2: &InMemDicomObject<D>)
     where
diff --git a/object/src/util.rs b/object/src/util.rs
deleted file mode 100644
index cc3a5df65..000000000
--- a/object/src/util.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use std::io;
-use std::io::{Read, Seek, SeekFrom};
-
-/** A private type trait for the ability to efficiently implement stream skipping.
- */
-pub trait ForwardSeek {
-    fn skip(&mut self, n: u64) -> io::Result<u64>;
-}
-
-impl<S: ?Sized> ForwardSeek for S
-where
-    S: Seek,
-{
-    fn skip(&mut self, n: u64) -> io::Result<u64> {
-        let curr_pos = self.stream_position()?;
-        let new_pos = self.seek(SeekFrom::Current(n as i64))?;
-        Ok(new_pos - curr_pos)
-    }
-}
-
-/// A trait that combines for `Read` and `Seek`.
-pub trait ReadSeek: Read + Seek {}
-impl<T: ?Sized> ReadSeek for T where T: Read + Seek {}
diff --git a/object/tests/integration_test.rs b/object/tests/integration_test.rs
index 658889efd..86b599e72 100644
--- a/object/tests/integration_test.rs
+++ b/object/tests/integration_test.rs
@@ -11,8 +11,6 @@ use dicom_object::{
     mem::InMemDicomObject,
     open_file,
 };
-use dicom_test_files;
-
 #[test]
 fn test_ob_value_with_unknown_length() {
     let path =
diff --git a/parser/src/dataset/read.rs b/parser/src/dataset/read.rs
index 8d856f7a6..19987a731 100644
--- a/parser/src/dataset/read.rs
+++ b/parser/src/dataset/read.rs
@@ -12,7 +12,6 @@ use dicom_encoding::transfer_syntax::TransferSyntax;
 use snafu::{Backtrace, ResultExt, Snafu};
 use std::cmp::Ordering;
 use std::io::Read;
-use std::iter::Iterator;
 
 use super::{DataToken, SeqTokenType};
 
diff --git a/parser/src/dataset/write.rs b/parser/src/dataset/write.rs
index 45fa98762..bfa77faf8 100644
--- a/parser/src/dataset/write.rs
+++ b/parser/src/dataset/write.rs
@@ -6,9 +6,9 @@
 //! to a writer.
 //! In this process, the writer will also adapt values
 //! to the necessary DICOM encoding rules.
-use crate::dataset::*;
+use crate::dataset::{DataToken, SeqTokenType};
 use crate::stateful::encode::StatefulEncoder;
-use dicom_core::{DataElementHeader, Length, VR};
+use dicom_core::{DataElementHeader, Length, Tag, VR};
 use dicom_encoding::encode::EncodeTo;
 use dicom_encoding::text::SpecificCharacterSet;
 use dicom_encoding::transfer_syntax::DynEncoder;
diff --git a/parser/src/stateful/decode.rs b/parser/src/stateful/decode.rs
index 72d24bbac..b3b5a9ee9 100644
--- a/parser/src/stateful/decode.rs
+++ b/parser/src/stateful/decode.rs
@@ -18,7 +18,6 @@ use dicom_encoding::transfer_syntax::{DynDecoder, TransferSyntax};
 use smallvec::smallvec;
 use snafu::{Backtrace, OptionExt, ResultExt, Snafu};
 use std::io::Read;
-use std::iter::Iterator;
 use std::{fmt::Debug, io::Seek, io::SeekFrom};
 
 #[derive(Debug, Snafu)]
diff --git a/parser/src/util.rs b/parser/src/util.rs
index 63e88d717..ab76e72b2 100644
--- a/parser/src/util.rs
+++ b/parser/src/util.rs
@@ -1,22 +1,4 @@
-use std::io;
-use std::io::{Read, Seek, SeekFrom};
-
-/** A private type trait for the ability to efficiently implement stream skipping.
- */
-pub trait ForwardSeek {
-    fn skip(&mut self, n: u64) -> io::Result<u64>;
-}
-
-impl<S: ?Sized> ForwardSeek for S
-where
-    S: Seek,
-{
-    fn skip(&mut self, n: u64) -> io::Result<u64> {
-        let curr_pos = self.stream_position()?;
-        let new_pos = self.seek(SeekFrom::Current(n as i64))?;
-        Ok(new_pos - curr_pos)
-    }
-}
+use std::io::{Read, Seek};
 
 pub trait ReadSeek: Read + Seek {}
 impl<T: ?Sized> ReadSeek for T where T: Read + Seek {}
diff --git a/pixeldata/src/gdcm.rs b/pixeldata/src/gdcm.rs
index f96c1a56f..d70e6d5e1 100644
--- a/pixeldata/src/gdcm.rs
+++ b/pixeldata/src/gdcm.rs
@@ -2,7 +2,6 @@
 
 use crate::*;
 use dicom_dictionary_std::tags;
-use dicom_encoding::adapters::DecodeError;
 use dicom_encoding::transfer_syntax::TransferSyntaxIndex;
 use dicom_transfer_syntax_registry::TransferSyntaxRegistry;
 use gdcm_rs::{
diff --git a/pixeldata/src/lib.rs b/pixeldata/src/lib.rs
index 5fe82017f..860cfb3b9 100644
--- a/pixeldata/src/lib.rs
+++ b/pixeldata/src/lib.rs
@@ -1981,7 +1981,6 @@ where
 mod tests {
     use super::*;
     use dicom_object::open_file;
-    use dicom_test_files;
 
     fn is_send_and_sync<T>()
     where
diff --git a/pixeldata/src/transcode.rs b/pixeldata/src/transcode.rs
index 0295dd72f..7e64c10d4 100644
--- a/pixeldata/src/transcode.rs
+++ b/pixeldata/src/transcode.rs
@@ -36,9 +36,6 @@ pub(crate) enum InnerError {
     /// Could not decode pixel data of receiving object  
     DecodePixelData { source: crate::Error },
 
-    /// Could not read receiving object
-    ReadObject { source: dicom_object::ReadError },
-
     /// Could not encode pixel data to target encoding
     EncodePixelData {
         source: dicom_encoding::adapters::EncodeError,
@@ -46,9 +43,6 @@ pub(crate) enum InnerError {
 
     /// Unsupported bits per sample ({bits_allocated})
     UnsupportedBitsAllocated { bits_allocated: u16 },
-
-    /// Encoding multi-frame objects is not implemented
-    MultiFrameEncodingNotImplemented,
 }
 
 /// Alias for the result of transcoding a DICOM object.
@@ -275,7 +269,6 @@ mod tests {
     use super::*;
     use dicom_dictionary_std::uids;
     use dicom_object::open_file;
-    use dicom_test_files;
     use dicom_transfer_syntax_registry::entries::{JPEG_EXTENDED, ENCAPSULATED_UNCOMPRESSED_EXPLICIT_VR_LITTLE_ENDIAN};
     #[cfg(feature = "native")]
     use dicom_transfer_syntax_registry::entries::JPEG_BASELINE;
diff --git a/transfer-syntax-registry/src/adapters/rle_lossless.rs b/transfer-syntax-registry/src/adapters/rle_lossless.rs
index cf89c8922..e3f06a7ce 100644
--- a/transfer-syntax-registry/src/adapters/rle_lossless.rs
+++ b/transfer-syntax-registry/src/adapters/rle_lossless.rs
@@ -252,7 +252,7 @@ impl PackBitsReader {
                 bytes_read += 1;
             } else if h >= 0 {
                 let num_vals = h as usize + 1;
-                std::io::copy(&mut reader.by_ref().take(num_vals as u64), &mut buffer)?;
+                io::copy(&mut reader.by_ref().take(num_vals as u64), &mut buffer)?;
                 bytes_read += num_vals;
             } else {
                 // h = -128 is a no-op.