Replace 'impl private' pattern with pub(crate)

src/de.rs

@@ -3,7 +3,7 @@
 //! This module provides YAML deserialization with the type `Deserializer`.
 
 use crate::path::Path;
-use crate::{private, Error, Result};
+use crate::{error, Error, Result};
 use serde::de::{
     self, Deserialize, DeserializeOwned, DeserializeSeed, Expected, IgnoredAny as Ignore,
     IntoDeserializer, Unexpected, Visitor,
@@ -76,12 +76,12 @@ impl<'a> Deserializer<'a> {
     fn peek(&self) -> Result<(&'a Event, Marker)> {
         match self.events.get(*self.pos) {
             Some(event) => Ok((&event.0, event.1)),
-            None => Err(private::error_end_of_stream()),
+            None => Err(error::end_of_stream()),
         }
     }
 
     fn next(&mut self) -> Result<(&'a Event, Marker)> {
-        self.opt_next().ok_or_else(private::error_end_of_stream)
+        self.opt_next().ok_or_else(error::end_of_stream)
     }
 
     fn opt_next(&mut self) -> Option<(&'a Event, Marker)> {
@@ -235,7 +235,7 @@ impl<'a> Deserializer<'a> {
         let previous_depth = self.remaining_depth;
         self.remaining_depth = previous_depth
             .checked_sub(1)
-            .ok_or_else(private::error_recursion_limit_exceeded)?;
+            .ok_or_else(error::recursion_limit_exceeded)?;
         let result = f(self);
         self.remaining_depth = previous_depth;
         result
@@ -638,7 +638,7 @@ impl<'a> Deserializer<'a> {
             Event::Scalar(ref v, style, ref tag) => visit_scalar(v, style, tag, visitor),
             ref other => Err(invalid_type(other, &visitor)),
         }
-        .map_err(|err| private::fix_marker(err, marker, self.path))
+        .map_err(|err| error::fix_marker(err, marker, self.path))
     }
 }
 
@@ -660,7 +660,7 @@ impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut Deserializer<'a> {
         }
         // The de::Error impl creates errors with unknown line and column. Fill
         // in the position here by looking at the current index in the input.
-        .map_err(|err| private::fix_marker(err, marker, self.path))
+        .map_err(|err| error::fix_marker(err, marker, self.path))
     }
 
     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
@@ -775,7 +775,7 @@ impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut Deserializer<'a> {
             Event::Alias(mut pos) => self.jump(&mut pos)?.deserialize_str(visitor),
             ref other => Err(invalid_type(other, &visitor)),
         }
-        .map_err(|err: Error| private::fix_marker(err, marker, self.path))
+        .map_err(|err: Error| error::fix_marker(err, marker, self.path))
     }
 
     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
@@ -870,7 +870,7 @@ impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut Deserializer<'a> {
             Event::SequenceStart => self.visit_sequence(visitor),
             ref other => Err(invalid_type(other, &visitor)),
         }
-        .map_err(|err| private::fix_marker(err, marker, self.path))
+        .map_err(|err| error::fix_marker(err, marker, self.path))
     }
 
     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
@@ -902,7 +902,7 @@ impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut Deserializer<'a> {
             Event::MappingStart => self.visit_mapping(visitor),
             ref other => Err(invalid_type(other, &visitor)),
         }
-        .map_err(|err| private::fix_marker(err, marker, self.path))
+        .map_err(|err| error::fix_marker(err, marker, self.path))
     }
 
     fn deserialize_struct<V>(
@@ -923,7 +923,7 @@ impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut Deserializer<'a> {
             Event::MappingStart => self.visit_mapping(visitor),
             ref other => Err(invalid_type(other, &visitor)),
         }
-        .map_err(|err| private::fix_marker(err, marker, self.path))
+        .map_err(|err| error::fix_marker(err, marker, self.path))
     }
 
     /// Parses an enum as a single key:value pair where the key identifies the
@@ -971,7 +971,7 @@ impl<'de, 'a, 'r> de::Deserializer<'de> for &'r mut Deserializer<'a> {
             }
             Event::SequenceStart => {
                 let err = de::Error::invalid_type(Unexpected::Seq, &"string or singleton map");
-                Err(private::fix_marker(err, marker, self.path))
+                Err(error::fix_marker(err, marker, self.path))
             }
             Event::SequenceEnd => panic!("unexpected end of sequence"),
             Event::MappingEnd => panic!("unexpected end of mapping"),
@@ -1034,9 +1034,9 @@ where
     };
     parser
         .load(&mut loader, true)
-        .map_err(private::error_scanner)?;
+        .map_err(error::scanner)?;
     if loader.events.is_empty() {
-        Err(private::error_end_of_stream())
+        Err(error::end_of_stream())
     } else {
         let mut pos = 0;
         let t = seed.deserialize(&mut Deserializer {
@@ -1049,7 +1049,7 @@ where
         if pos == loader.events.len() {
             Ok(t)
         } else {
-            Err(private::error_more_than_one_document())
+            Err(error::more_than_one_document())
         }
     }
 }
@@ -1086,7 +1086,7 @@ where
     S: for<'de> DeserializeSeed<'de, Value = T>,
 {
     let mut bytes = Vec::new();
-    rdr.read_to_end(&mut bytes).map_err(private::error_io)?;
+    rdr.read_to_end(&mut bytes).map_err(error::io)?;
     from_slice_seed(&bytes, seed)
 }
 
@@ -1123,6 +1123,6 @@ pub fn from_slice_seed<T, S>(v: &[u8], seed: S) -> Result<T>
 where
     S: for<'de> DeserializeSeed<'de, Value = T>,
 {
-    let s = str::from_utf8(v).map_err(private::error_str_utf8)?;
+    let s = str::from_utf8(v).map_err(error::str_utf8)?;
     from_str_seed(s, seed)
 }

src/error.rs

@@ -1,5 +1,4 @@
 use crate::path::Path;
-use crate::private;
 use serde::{de, ser};
 use std::error;
 use std::fmt::{self, Debug, Display};
@@ -103,48 +102,46 @@ impl Error {
     }
 }
 
-impl private {
-    pub fn error_end_of_stream() -> Error {
-        Error(Box::new(ErrorImpl::EndOfStream))
-    }
+pub(crate) fn end_of_stream() -> Error {
+    Error(Box::new(ErrorImpl::EndOfStream))
+}
 
-    pub fn error_more_than_one_document() -> Error {
-        Error(Box::new(ErrorImpl::MoreThanOneDocument))
-    }
+pub(crate) fn more_than_one_document() -> Error {
+    Error(Box::new(ErrorImpl::MoreThanOneDocument))
+}
 
-    pub fn error_io(err: io::Error) -> Error {
-        Error(Box::new(ErrorImpl::Io(err)))
-    }
+pub(crate) fn io(err: io::Error) -> Error {
+    Error(Box::new(ErrorImpl::Io(err)))
+}
 
-    pub fn error_emitter(err: emitter::EmitError) -> Error {
-        Error(Box::new(ErrorImpl::Emit(err)))
-    }
+pub(crate) fn emitter(err: emitter::EmitError) -> Error {
+    Error(Box::new(ErrorImpl::Emit(err)))
+}
 
-    pub fn error_scanner(err: scanner::ScanError) -> Error {
-        Error(Box::new(ErrorImpl::Scan(err)))
-    }
+pub(crate) fn scanner(err: scanner::ScanError) -> Error {
+    Error(Box::new(ErrorImpl::Scan(err)))
+}
 
-    pub fn error_str_utf8(err: str::Utf8Error) -> Error {
-        Error(Box::new(ErrorImpl::Utf8(err)))
-    }
+pub(crate) fn str_utf8(err: str::Utf8Error) -> Error {
+    Error(Box::new(ErrorImpl::Utf8(err)))
+}
 
-    pub fn error_string_utf8(err: string::FromUtf8Error) -> Error {
-        Error(Box::new(ErrorImpl::FromUtf8(err)))
-    }
+pub(crate) fn string_utf8(err: string::FromUtf8Error) -> Error {
+    Error(Box::new(ErrorImpl::FromUtf8(err)))
+}
 
-    pub fn error_recursion_limit_exceeded() -> Error {
-        Error(Box::new(ErrorImpl::RecursionLimitExceeded))
-    }
+pub(crate) fn recursion_limit_exceeded() -> Error {
+    Error(Box::new(ErrorImpl::RecursionLimitExceeded))
+}
 
-    pub fn fix_marker(mut error: Error, marker: Marker, path: Path) -> Error {
-        if let ErrorImpl::Message(_, ref mut none @ None) = *error.0.as_mut() {
-            *none = Some(Pos {
-                marker: marker,
-                path: path.to_string(),
-            });
-        }
-        error
+pub(crate) fn fix_marker(mut error: Error, marker: Marker, path: Path) -> Error {
+    if let ErrorImpl::Message(_, ref mut none @ None) = *error.0.as_mut() {
+        *none = Some(Pos {
+            marker: marker,
+            path: path.to_string(),
+        });
     }
+    error
 }
 
 impl error::Error for Error {

src/lib.rs

@@ -109,6 +109,3 @@ mod number;
 mod path;
 mod ser;
 mod value;
-
-#[allow(non_camel_case_types)]
-enum private {}

src/number.rs

@@ -1,4 +1,4 @@
-use crate::{private, Error};
+use crate::Error;
 use serde::de::{Unexpected, Visitor};
 use serde::{forward_to_deserialize_any, Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{self, Debug, Display};
@@ -496,12 +496,10 @@ impl Hash for Number {
     }
 }
 
-impl private {
-    pub fn number_unexpected(number: &Number) -> Unexpected {
-        match number.n {
-            N::PosInt(u) => Unexpected::Unsigned(u),
-            N::NegInt(i) => Unexpected::Signed(i),
-            N::Float(f) => Unexpected::Float(f),
-        }
+pub(crate) fn unexpected(number: &Number) -> Unexpected {
+    match number.n {
+        N::PosInt(u) => Unexpected::Unsigned(u),
+        N::NegInt(i) => Unexpected::Signed(i),
+        N::Float(f) => Unexpected::Float(f),
     }
 }

src/ser.rs

@@ -2,7 +2,7 @@
 //!
 //! This module provides YAML serialization with the type `Serializer`.
 
-use crate::{private, Error, Result};
+use crate::{error, Error, Result};
 use serde::{ser, serde_if_integer128};
 use std::{fmt, io, num, str};
 use yaml_rust::{yaml, Yaml, YamlEmitter};
@@ -395,7 +395,7 @@ where
     let mut writer_adapter = FmtToIoWriter { writer: writer };
     YamlEmitter::new(&mut writer_adapter)
         .dump(&doc)
-        .map_err(private::error_emitter)?;
+        .map_err(error::emitter)?;
     Ok(())
 }
 
@@ -420,7 +420,7 @@ pub fn to_string<T: ?Sized>(value: &T) -> Result<String>
 where
     T: ser::Serialize,
 {
-    Ok(String::from_utf8(to_vec(value)?).map_err(private::error_string_utf8)?)
+    Ok(String::from_utf8(to_vec(value)?).map_err(error::string_utf8)?)
 }
 
 /// The yaml-rust library uses `fmt::Write` intead of `io::Write` so this is a

src/value/de.rs

@@ -1,4 +1,4 @@
-use crate::{private, Error, Mapping, Sequence, Value};
+use crate::{number, Error, Mapping, Sequence, Value};
 use serde::de::{
     self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as SError, Expected,
     MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor,
@@ -705,7 +705,7 @@ impl Value {
         match *self {
             Value::Null => Unexpected::Unit,
             Value::Bool(b) => Unexpected::Bool(b),
-            Value::Number(ref n) => private::number_unexpected(n),
+            Value::Number(ref n) => number::unexpected(n),
             Value::String(ref s) => Unexpected::Str(s),
             Value::Sequence(_) => Unexpected::Seq,
             Value::Mapping(_) => Unexpected::Map,