Move nom into nom_core workspace

This allows for the re-export of not only nom-core, thus making
this a no-change to the api, it also allows for reexport of other community extensions, such as num-supreme

Cargo.toml

@@ -27,17 +27,15 @@ include = [
   "tests/*.rs",
   "doc/nom_recipes.md",
 ]
+[dependencies]
+nom_core = {path = "./nom_core"}
 
 [features]
-alloc = []
-std = ["alloc", "memchr/std"]
+alloc = ["nom_core/alloc"]
+std = ["nom_core/std"]
 default = ["std"]
 docsrs = []
 
-[dependencies.memchr]
-version = "2.3"
-default-features = false
-
 [dev-dependencies]
 doc-comment = "0.3"
 proptest = "=1.0.0"
@@ -142,4 +140,4 @@ coveralls = { repository = "Geal/nom", branch = "main", service = "github" }
 maintenance = { status = "actively-developed" }
 
 [workspace]
-members = [".", "benchmarks/"]
+members = [".", "benchmarks/", "nom_core"]

nom_core/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "nom_core"
+version = "0.1.0"
+edition = "2021"
+
+
+[features]
+alloc = []
+std = ["alloc", "memchr/std"]
+default = ["std"]
+docsrs = []
+
+[dependencies.memchr]
+version = "2.3"
+default-features = false
+[dev-dependencies]
+doc-comment = "0.3"
+proptest = "=1.0.0"

src/bits/complete.rs → nom_core/src/bits/complete.rs

@@ -10,6 +10,7 @@ use crate::traits::{Input, ToUsize};
 ///
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::bits::complete::take;
 /// # use nom::IResult;
 /// # use nom::error::{Error, ErrorKind};
@@ -107,6 +108,7 @@ where
 ///
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::bits::complete::bool;
 /// # use nom::IResult;
 /// # use nom::error::{Error, ErrorKind};

src/bits/mod.rs → nom_core/src/bits/mod.rs

@@ -15,7 +15,8 @@ use crate::Input;
 /// away.
 ///
 /// # Example
-/// ```
+/// ```rust
+/// # use nom_core as nom;
 /// use nom::bits::{bits, streaming::take};
 /// use nom::error::Error;
 /// use nom::IResult;
@@ -63,7 +64,8 @@ where
 /// A partial byte remaining in the input will be ignored and the given parser will start parsing
 /// at the next full byte.
 ///
-/// ```
+/// ```rust
+/// # use nom_core as nom;
 /// use nom::bits::{bits, bytes, streaming::take};
 /// use nom::combinator::rest;
 /// use nom::error::Error;

src/bits/streaming.rs → nom_core/src/bits/streaming.rs

@@ -83,6 +83,7 @@ where
 ///
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::bits::complete::bool;
 /// # use nom::IResult;
 /// # use nom::error::{Error, ErrorKind};

src/branch/mod.rs → nom_core/src/branch/mod.rs

@@ -16,6 +16,7 @@ use crate::internal::{Err, Mode, Parser};
 /// use an array.
 ///
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::error_position;
 /// # use nom::{Err,error::ErrorKind, Needed, IResult, Parser};
 /// use nom::character::complete::{alpha1, digit1};
@@ -49,6 +50,7 @@ pub fn alt<List>(l: List) -> Choice<List> {
 /// tuple of the parser results.
 ///
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err,error::{Error, ErrorKind}, Needed, IResult, Parser};
 /// use nom::character::complete::{alpha1, digit1};
 /// use nom::branch::permutation;
@@ -71,6 +73,7 @@ pub fn alt<List>(l: List) -> Choice<List> {
 /// The parsers are applied greedily: if there are multiple unapplied parsers
 /// that could parse the next slice of input, the first one is used.
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, IResult, Parser};
 /// use nom::branch::permutation;
 /// use nom::character::complete::{anychar, char};

src/bytes/complete.rs → nom_core/src/bytes/complete.rs

@@ -18,6 +18,7 @@ use crate::OutputM;
 /// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::tag;
 ///
@@ -52,6 +53,7 @@ where
 /// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::tag_no_case;
 ///
@@ -89,6 +91,7 @@ where
 /// It will return a `Err::Error(("", ErrorKind::IsNot))` if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::is_not;
 ///
@@ -119,6 +122,7 @@ where
 /// It will return a `Err(Err::Error((_, ErrorKind::IsA)))` if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::is_a;
 ///
@@ -148,6 +152,7 @@ where
 /// takes the input and returns a bool)*.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// use nom::bytes::complete::take_while;
 /// use nom::AsChar;
@@ -179,6 +184,7 @@ where
 /// It will return an `Err(Err::Error((_, ErrorKind::TakeWhile1)))` if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::take_while1;
 /// use nom::AsChar;
@@ -210,6 +216,7 @@ where
 /// of range (m <= len <= n).
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::take_while_m_n;
 /// use nom::AsChar;
@@ -244,6 +251,7 @@ where
 /// takes the input and returns a bool)*.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// use nom::bytes::complete::take_till;
 ///
@@ -276,6 +284,7 @@ where
 /// predicate matches the first input.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::take_till1;
 ///
@@ -304,6 +313,7 @@ where
 /// It will return `Err(Err::Error((_, ErrorKind::Eof)))` if the input is shorter than the argument.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::take;
 ///
@@ -322,6 +332,7 @@ where
 /// take that many `u8`'s:
 ///
 /// ```rust
+/// # use nom_core as nom;
 /// use nom::error::Error;
 /// use nom::bytes::complete::take;
 ///
@@ -344,6 +355,7 @@ where
 /// if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::take_until;
 ///
@@ -372,6 +384,7 @@ where
 /// if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::take_until1;
 ///
@@ -401,7 +414,8 @@ where
 /// * The second argument is the control character (like `\` in most languages)
 /// * The third argument matches the escaped characters
 /// # Example
-/// ```
+/// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// # use nom::character::complete::digit1;
 /// use nom::bytes::complete::escaped;
@@ -440,7 +454,8 @@ where
 ///
 /// As an example, the chain `abc\tdef` could be `abc    def` (it also consumes the control character)
 ///
-/// ```
+/// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// # use std::str::from_utf8;
 /// use nom::bytes::complete::{escaped_transform, tag};

src/bytes/mod.rs → nom_core/src/bytes/mod.rs

@@ -30,6 +30,7 @@ use crate::ToUsize;
 /// the input that matches the argument.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::streaming::tag;
 ///
@@ -98,6 +99,7 @@ where
 /// the input that matches the argument with no regard to case.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::streaming::tag_no_case;
 ///
@@ -213,6 +215,7 @@ where
 /// It will return a `Err::Error(("", ErrorKind::IsNot))` if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::is_not;
 ///
@@ -245,6 +248,7 @@ where
 /// It will return a `Err(Err::Error((_, ErrorKind::IsA)))` if the pattern wasn't met.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::complete::is_a;
 ///
@@ -276,6 +280,7 @@ where
 /// takes the input and returns a bool)*.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// use nom::bytes::complete::take_while;
 /// use nom::character::is_alphabetic;
@@ -312,6 +317,7 @@ where
 ///
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::streaming::take_while1;
 /// use nom::character::is_alphabetic;
@@ -347,6 +353,7 @@ where
 ///
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::streaming::take_while_m_n;
 /// use nom::character::is_alphabetic;
@@ -449,6 +456,7 @@ where
 /// takes the input and returns a bool)*.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// use nom::bytes::complete::take_till;
 ///
@@ -483,6 +491,7 @@ where
 /// end of input or if there was not match.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::streaming::take_till1;
 ///
@@ -520,6 +529,7 @@ where
 ///
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// use nom::bytes::streaming::take;
 ///
@@ -581,6 +591,7 @@ where
 /// contain the pattern or if the input is smaller than the pattern.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// use nom::bytes::streaming::take_until;
 ///
@@ -644,6 +655,7 @@ where
 /// contain the pattern or if the input is smaller than the pattern.
 /// # Example
 /// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
 /// use nom::bytes::streaming::take_until1;
 ///
@@ -709,7 +721,8 @@ where
 /// * The second argument is the control character (like `\` in most languages)
 /// * The third argument matches the escaped characters
 /// # Example
-/// ```
+/// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// # use nom::character::complete::digit1;
 /// use nom::bytes::streaming::escaped;
@@ -874,7 +887,8 @@ where
 ///
 /// As an example, the chain `abc\tdef` could be `abc    def` (it also consumes the control character)
 ///
-/// ```
+/// ```rust
+/// # use nom_core as nom;
 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
 /// # use std::str::from_utf8;
 /// use nom::bytes::streaming::{escaped_transform, tag};