Clarify the internal module name

src/bits/complete.rs

@@ -2,8 +2,8 @@
 //!
 
 use crate::error::{ErrorKind, ParseError};
-use crate::internal::{Err, IResult};
 use crate::lib::std::ops::{AddAssign, Div, RangeFrom, Shl, Shr};
+use crate::parser::{Err, IResult};
 use crate::traits::{InputIter, InputLength, Slice, ToUsize};
 
 /// Generates a parser taking `count` bits

src/bits/mod.rs

@@ -5,8 +5,8 @@ pub mod complete;
 pub mod streaming;
 
 use crate::error::{ErrorKind, ParseError};
-use crate::internal::{Err, IResult, Needed};
 use crate::lib::std::ops::RangeFrom;
+use crate::parser::{Err, IResult, Needed};
 use crate::traits::{ErrorConvert, Slice};
 
 /// Converts a byte-level input to a bit-level input, for consumption by a parser that uses bits.

src/bits/streaming.rs

@@ -2,8 +2,8 @@
 //!
 
 use crate::error::{ErrorKind, ParseError};
-use crate::internal::{Err, IResult, Needed};
 use crate::lib::std::ops::{AddAssign, Div, RangeFrom, Shl, Shr};
+use crate::parser::{Err, IResult, Needed};
 use crate::traits::{InputIter, InputLength, Slice, ToUsize};
 
 /// Generates a parser taking `count` bits

src/branch/mod.rs

@@ -29,7 +29,7 @@ mod tests;
 
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult, Parser};
+use crate::parser::{Err, IResult, Parser};
 
 /// Helper trait for the [alt()] combinator.
 ///

src/branch/tests.rs

@@ -1,7 +1,7 @@
 use crate::branch::{alt, permutation};
 use crate::bytes::streaming::tag;
 use crate::error::ErrorKind;
-use crate::internal::{Err, IResult, Needed};
+use crate::parser::{Err, IResult, Needed};
 #[cfg(feature = "alloc")]
 use crate::{
   error::ParseError,

src/bytes/complete.rs

@@ -2,9 +2,9 @@
 
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult, Parser};
 use crate::lib::std::ops::RangeFrom;
 use crate::lib::std::result::Result::*;
+use crate::parser::{Err, IResult, Parser};
 use crate::traits::{
   Compare, CompareResult, FindSubstring, FindToken, InputIter, InputLength, InputTake,
   InputTakeAtPosition, Slice, ToUsize,

src/bytes/streaming.rs

@@ -2,9 +2,9 @@
 
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult, Needed, Parser};
 use crate::lib::std::ops::RangeFrom;
 use crate::lib::std::result::Result::*;
+use crate::parser::{Err, IResult, Needed, Parser};
 use crate::traits::{
   Compare, CompareResult, FindSubstring, FindToken, InputIter, InputLength, InputTake,
   InputTakeAtPosition, Slice, ToUsize,

src/bytes/tests.rs

@@ -4,7 +4,7 @@ use crate::character::streaming::{
   multispace1 as multispace, oct_digit1 as oct_digit, space1 as space,
 };
 use crate::error::ErrorKind;
-use crate::internal::{Err, IResult, Needed};
+use crate::parser::{Err, IResult, Needed};
 #[cfg(feature = "alloc")]
 use crate::{
   branch::alt,

src/character/complete.rs

@@ -6,8 +6,8 @@ use crate::branch::alt;
 use crate::combinator::opt;
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult};
 use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
+use crate::parser::{Err, IResult};
 use crate::traits::{
   AsChar, FindToken, InputIter, InputLength, InputTake, InputTakeAtPosition, Slice,
 };
@@ -414,23 +414,23 @@ where
 /// assert_eq!(parser("c1"), Err(Err::Error(Error::new("c1", ErrorKind::Digit))));
 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Digit))));
 /// ```
-/// 
+///
 /// ## Parsing an integer
 /// You can use `digit1` in combination with [`map_res`] to parse an integer:
-/// 
+///
 /// ```
 /// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
 /// # use nom::combinator::map_res;
 /// # use nom::character::complete::digit1;
 /// fn parser(input: &str) -> IResult<&str, u32> {
 ///   map_res(digit1, str::parse)(input)
 /// }
-/// 
+///
 /// assert_eq!(parser("416"), Ok(("", 416)));
 /// assert_eq!(parser("12b"), Ok(("b", 12)));
 /// assert!(parser("b").is_err());
 /// ```
-/// 
+///
 /// [`map_res`]: crate::combinator::map_res
 pub fn digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
 where
@@ -831,7 +831,7 @@ uints! { u8 u16 u32 u64 u128 }
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::internal::Err;
+  use crate::parser::Err;
   use crate::traits::ParseTo;
   use proptest::prelude::*;
 

src/character/streaming.rs

@@ -6,8 +6,8 @@ use crate::branch::alt;
 use crate::combinator::opt;
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult, Needed};
 use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
+use crate::parser::{Err, IResult, Needed};
 use crate::traits::{
   AsChar, FindToken, InputIter, InputLength, InputTake, InputTakeAtPosition, Slice,
 };
@@ -738,7 +738,7 @@ uints! { u8 u16 u32 u64 u128 }
 mod tests {
   use super::*;
   use crate::error::ErrorKind;
-  use crate::internal::{Err, Needed};
+  use crate::parser::{Err, Needed};
   use crate::sequence::pair;
   use crate::traits::ParseTo;
   use proptest::prelude::*;

src/character/tests.rs

@@ -1,6 +1,6 @@
 use super::streaming::*;
 use crate::error::ErrorKind;
-use crate::internal::{Err, IResult};
+use crate::parser::{Err, IResult};
 
 #[test]
 fn one_of_test() {

src/combinator/mod.rs

@@ -6,13 +6,13 @@
 use crate::lib::std::boxed::Box;
 
 use crate::error::{ErrorKind, FromExternalError, ParseError};
-use crate::internal::*;
 use crate::lib::std::borrow::Borrow;
 use crate::lib::std::convert::Into;
 #[cfg(feature = "std")]
 use crate::lib::std::fmt::Debug;
 use crate::lib::std::mem::transmute;
 use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
+use crate::parser::*;
 use crate::traits::{AsChar, InputIter, InputLength, InputTakeAtPosition, ParseTo};
 use crate::traits::{Compare, CompareResult, Offset, Slice};
 

src/combinator/tests.rs

@@ -3,10 +3,10 @@ use crate::bytes::complete::take;
 use crate::bytes::streaming::tag;
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult, Needed};
 #[cfg(feature = "alloc")]
 use crate::lib::std::boxed::Box;
 use crate::number::complete::u8;
+use crate::parser::{Err, IResult, Needed};
 
 macro_rules! assert_parse(
   ($left: expr, $right: expr) => {

src/error.rs

@@ -3,8 +3,8 @@
 //! Parsers are generic over their error type, requiring that it implements
 //! the `error::ParseError<Input>` trait.
 
-use crate::internal::Parser;
 use crate::lib::std::fmt;
+use crate::parser::Parser;
 
 /// This trait must be implemented by the error type of a nom parser.
 ///
@@ -225,7 +225,7 @@ impl<I: fmt::Display> fmt::Display for VerboseError<I> {
 #[cfg(feature = "std")]
 impl<I: fmt::Debug + fmt::Display> std::error::Error for VerboseError<I> {}
 
-use crate::internal::{Err, IResult};
+use crate::parser::{Err, IResult};
 
 /// Create a new error from an input position, a static string and an existing error.
 /// This is used mainly in the [context] combinator, to add user friendly information

src/lib.rs

@@ -433,7 +433,7 @@ pub mod lib {
 }
 
 pub use self::bits::*;
-pub use self::internal::*;
+pub use self::parser::*;
 pub use self::traits::*;
 
 pub use self::str::*;
@@ -442,7 +442,7 @@ pub use self::str::*;
 pub mod error;
 
 pub mod combinator;
-mod internal;
+mod parser;
 mod traits;
 #[macro_use]
 pub mod branch;

src/multi/mod.rs

@@ -5,9 +5,9 @@ mod tests;
 
 use crate::error::ErrorKind;
 use crate::error::ParseError;
-use crate::internal::{Err, IResult, Needed, Parser};
 #[cfg(feature = "alloc")]
 use crate::lib::std::vec::Vec;
+use crate::parser::{Err, IResult, Needed, Parser};
 use crate::traits::{InputLength, InputTake, ToUsize};
 use core::num::NonZeroUsize;
 

src/multi/tests.rs

@@ -3,9 +3,9 @@ use crate::{
   bytes::streaming::tag,
   character::streaming::digit1 as digit,
   error::{ErrorKind, ParseError},
-  internal::{Err, IResult, Needed},
   lib::std::str::{self, FromStr},
   number::streaming::{be_u16, be_u8},
+  parser::{Err, IResult, Needed},
   sequence::{pair, tuple},
 };
 #[cfg(feature = "alloc")]

src/number/complete.rs

@@ -6,8 +6,8 @@ use crate::character::complete::{char, digit1, sign};
 use crate::combinator::{cut, map, opt, recognize};
 use crate::error::ParseError;
 use crate::error::{make_error, ErrorKind};
-use crate::internal::*;
 use crate::lib::std::ops::{Range, RangeFrom, RangeTo};
+use crate::parser::*;
 use crate::sequence::{pair, tuple};
 use crate::traits::{
   AsBytes, AsChar, Compare, InputIter, InputLength, InputTake, InputTakeAtPosition, Offset, Slice,
@@ -1663,7 +1663,7 @@ where
 mod tests {
   use super::*;
   use crate::error::ErrorKind;
-  use crate::internal::Err;
+  use crate::parser::Err;
   use proptest::prelude::*;
 
   macro_rules! assert_parse(

src/number/streaming.rs

@@ -5,8 +5,8 @@ use crate::bytes::streaming::tag;
 use crate::character::streaming::{char, digit1, sign};
 use crate::combinator::{cut, map, opt, recognize};
 use crate::error::{ErrorKind, ParseError};
-use crate::internal::*;
 use crate::lib::std::ops::{RangeFrom, RangeTo};
+use crate::parser::*;
 use crate::sequence::{pair, tuple};
 use crate::traits::{
   AsBytes, AsChar, Compare, InputIter, InputLength, InputTake, InputTakeAtPosition, Offset, Slice,
@@ -1636,7 +1636,7 @@ where
 mod tests {
   use super::*;
   use crate::error::ErrorKind;
-  use crate::internal::{Err, Needed};
+  use crate::parser::{Err, Needed};
   use proptest::prelude::*;
 
   macro_rules! assert_parse(

src/sequence/mod.rs

@@ -4,7 +4,7 @@
 mod tests;
 
 use crate::error::ParseError;
-use crate::internal::{IResult, Parser};
+use crate::parser::{IResult, Parser};
 
 /// Gets an object from the first parser,
 /// then gets another object from the second parser.

src/sequence/tests.rs

@@ -1,8 +1,8 @@
 use super::*;
 use crate::bytes::streaming::{tag, take};
 use crate::error::ErrorKind;
-use crate::internal::{Err, IResult, Needed};
 use crate::number::streaming::be_u16;
+use crate::parser::{Err, IResult, Needed};
 
 #[test]
 fn single_element_tuples() {

src/str.rs

@@ -150,7 +150,7 @@ mod test {
     }
   }
 
-  use crate::internal::Needed;
+  use crate::parser::Needed;
 
   fn is_alphabetic(c: char) -> bool {
     (c as u8 >= 0x41 && c as u8 <= 0x5A) || (c as u8 >= 0x61 && c as u8 <= 0x7A)

src/traits.rs

@@ -1,13 +1,13 @@
 //! Traits input types have to implement to work with nom combinators
 use crate::error::{ErrorKind, ParseError};
-use crate::internal::{Err, IResult, Needed};
 use crate::lib::std::iter::{Copied, Enumerate};
 use crate::lib::std::ops::{Range, RangeFrom, RangeFull, RangeTo};
 use crate::lib::std::slice::Iter;
 use crate::lib::std::str::from_utf8;
 use crate::lib::std::str::CharIndices;
 use crate::lib::std::str::Chars;
 use crate::lib::std::str::FromStr;
+use crate::parser::{Err, IResult, Needed};
 
 #[cfg(feature = "alloc")]
 use crate::lib::std::string::String;