remove trailing punctuation in errors

src/flow/binary.rs

@@ -143,9 +143,9 @@ pub enum HeightError {
 impl Display for HeightError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::NodeHeight => write!(f, "invalid node height: 0."),
+            Self::NodeHeight => write!(f, "invalid node height: 0"),
             Self::LeafHeight(height) => {
-                write!(f, "invalid leaf height: {height}!=0.")
+                write!(f, "invalid leaf height: {height}!=0")
             }
         }
     }

src/flow/binary/balancing.rs

@@ -48,11 +48,11 @@ pub enum BalancingError {
 impl Display for BalancingError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Height(height_error) => write!(f, "invalid height: {height_error}."),
+            Self::Height(height_error) => write!(f, "invalid height: {height_error}"),
-            Self::Balance(hl, hr) => write!(f, "unbalanced node: {hl} {hr}."),
+            Self::Balance(hl, hr) => write!(f, "unbalanced node: {hl} {hr}"),
-            Self::HeightOverflow => write!(f, "tree height overflow."),
+            Self::HeightOverflow => write!(f, "tree height overflow"),
             Self::HeightMismatch { children, parent } => {
-                write!(f, "child-parent height mismatch: {children:?}, {parent}.")
+                write!(f, "child-parent height mismatch: {children:?}, {parent}")
             }
         }
     }

src/mrds/trees/heighted.rs

@@ -163,7 +163,7 @@ impl<'a, A: 'a + Ord + Clone> BinaryTreesUnbalanced<'a> for Trees<A> {
     }
 
     fn balancing_error<T: 'a>(&self, _error: BalancingError) -> BTWrap<'a, Self, T> {
-        panic!("balancing error.")
+        panic!("balancing error")
     }
 
     fn node_heights(&self, node: &Self::Node) -> (u64, u64) {
@@ -173,7 +173,7 @@ impl<'a, A: 'a + Ord + Clone> BinaryTreesUnbalanced<'a> for Trees<A> {
 
 impl<'a, A: 'a + Ord + Clone> BinaryTreesBindable<'a> for Trees<A> {
     fn bounds_error<T: 'a>(&self, _error: bounds::BoundsError<Self::Key>) -> BTWrap<'a, Self, T> {
-        panic!("bounds violated.");
+        panic!("bounds violated");
     }
 }
 

src/rcore/inlining.rs

@@ -27,7 +27,7 @@ pub trait InliningExt<E>: Inlining {
     ) -> Result<([u8; N], Self), E> {
         self.iread_n(
             N,
-            |slice| slice.try_into().expect("`iread_n` wrong length."),
+            |slice| slice.try_into().expect("`iread_n` wrong length"),
             err,
         )
     }

src/rstd/atomic/array.rs

@@ -17,10 +17,10 @@ pub enum ArrayParseError {
 impl Display for ArrayParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Eof => write!(f, "encountered EOF write parsing an array."),
+            Self::Eof => write!(f, "encountered EOF write parsing an array"),
             Self::ExtraData(length) => write!(
                 f,
-                "encountered extra data of length {length} while parsing an array.",
+                "encountered extra data of length {length} while parsing an array",
             ),
         }
     }

src/rstd/atomic/au64.rs

@@ -17,10 +17,10 @@ pub enum IntParseError {
 impl Display for IntParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Eof => write!(f, "encountered EOF write parsing an integer."),
+            Self::Eof => write!(f, "encountered EOF write parsing an integer"),
             Self::ExtraData(length) => write!(
                 f,
-                "encountered extra data of length {length} while parsing an integer.",
+                "encountered extra data of length {length} while parsing an integer",
             ),
         }
     }

src/rstd/atomic/boolean.rs

@@ -22,12 +22,12 @@ impl Display for BooleanParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::OutOfBounds(value) => {
-                write!(f, "boolean value out of bounds: {}.", value)
+                write!(f, "boolean value out of bounds: {}", value)
             }
-            Self::Eof => write!(f, "encountered EOF write parsing a boolean."),
+            Self::Eof => write!(f, "encountered EOF write parsing a boolean"),
             Self::ExtraData(length) => write!(
                 f,
-                "encountered extra data of length {length} while parsing a boolean.",
+                "encountered extra data of length {length} while parsing a boolean",
             ),
         }
     }

src/rstd/inlining.rs

@@ -118,7 +118,7 @@ impl Display for SizeError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "expected {} bytes, read/wrote {} instead.",
+            "expected {} bytes, read/wrote {} instead",
             self.expected, self.received
         )
     }

src/rstd/point.rs

@@ -48,7 +48,7 @@ impl Display for PointParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::WrongLength(length) => {
-                write!(f, "expected {} bytes, received {}.", HASH_SIZE, length)
+                write!(f, "expected {} bytes, received {}", HASH_SIZE, length)
             }
         }
     }

src/rstd/singular.rs

@@ -35,7 +35,7 @@ impl<'a, Ctx: Context<'a>> Resolver<'a, Ctx> for SingularResolver<'a, Ctx> {
     fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
         let point = self.points.get(address.index).unwrap_or_else(|| {
             panic!(
-                "singularity out-of-bounds: {}/{}.",
+                "singularity out-of-bounds: {}/{}",
                 address.index,
                 self.points.len()
             )

src/testing.rs

@@ -56,7 +56,7 @@ impl<'a> Display for TestLookupError<'a> {
                 write!(f, "cast failure: {}", cast_error)
             }
             Self::EmptyResolverAccess(address) => {
-                write!(f, "accessed an empty resolved at address {}.", address)
+                write!(f, "accessed an empty resolved at address {}", address)
             }
         }
     }