minparser 0.14.0

/*
 * Minparser Simple parsing functions
 *
 * Copyright (C) 2024-2025 Paolo De Donato
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
//! Parsing tools.
//!
//! This module provides the [`View`] object representing a string with its position inside a file,
//! and the [`Tool`] trait which is implemented by any object that respesents a parsing strategy.
use crate::pos::Position;

/// A view on a `str`.
///
/// This view carries a [`Position`] with respect of the initial string.
/// Each time a pattern is matched against a `View` object a new `View` object is returned,
/// returning the *remaining* part of the view which follows the matched prefix.
#[derive(Debug, Clone, Copy)]
pub struct View<'a> {
    pub(crate) view: &'a str,
    pub(crate) pos: Position,
}

#[derive(Debug, Clone, Copy)]
struct CursorData<'a, D> {
    pub(crate) view: &'a str,
    pos: Position,
    pub(crate) data: D,
}
#[must_use]
fn progress(pos: Position, view: &str, inc: usize) -> (&str, Position, &str) {
    if inc == 0 {
        ("", pos, view)
    } else {
        let (pfx, sfx) = view.split_at(inc);
        let mut fit = pfx.split('\n');
        let mut elem = fit.next().unwrap(); // at least one element
        let mut nls = 0;
        for el in fit {
            elem = el;
            nls += 1;
        }
        let (mut r, mut c) = pos.unpack();
        if nls > 0 {
            c = 0;
            r += nls;
        }
        c += u32::try_from(elem.len()).unwrap();
        (pfx, Position::new(r, c), sfx)
    }
}

/// A pointer to a location inside a string.
///
/// It is provided as an input argument of [`Tool`].
#[derive(Debug, Clone, Copy)]
pub struct CursorStart<'a>(CursorData<'a, ()>);

/// A [`Cursor`] that holds additional data.
#[derive(Debug, Clone, Copy)]
pub struct CursorLen<'a, D> {
    this: CursorData<'a, D>,
    // The length of the match, or equivalently how much bytes have been skipped, therefore this
    // points at the END of len.
    len: usize,
}

/// A position inside a string.
pub type Cursor<'a> = CursorLen<'a, ()>;

/// Parsing tool trait.
///
/// An object implementing this trait represents a parsing rule that are applied to string
/// prefixes. If any prefix of a string satisfy this rule then the match is successful and
/// additional data parsed from the matching prefix is returned. If instead no prefix satisfies the
/// rule then an error is returned.
pub trait Tool<'a> {
    /// Error type.
    type Error;
    /// Associated data type.
    type Data;

    /// The main parsing algorithm.
    ///
    /// On a successful match, it additionally returns the parsed data and the length of the match
    /// in bytes. You don't need to call this methos directly, just use [`chain`](CursorLen::chain)
    /// method of [`CursorLen`].
    ///
    /// # Errors
    /// If no prefix of `st` satisfies this parsing strategy then `Error` is returned.
    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error>;

    /// Applies a closure to generated data.
    fn map<D, F: Fn(Self::Data) -> D>(self, f: F) -> MapData<D, Self, F>
    where
        Self: Sized,
    {
        MapData(self, f, core::marker::PhantomData)
    }
}
/// A parsing tool that always match a prefix.
///
/// Any object implementing this trait must also implement the [`Tool`] trait and their
/// implementation of the [`parse`](Tool::parse) must be equivalent to
/// `Ok(self.parse_always(st))`.
///
/// It is a good practice to set [`core::convert::Infallible`] (or [`!`] when it will become
/// stable) as `Error`, but it is not mandatory.
pub trait AlwaysTool<'a>: Tool<'a> {
    /// The main parsing algorithm.
    fn parse_always(&self, st: CursorStart<'a>) -> CursorLen<'a, Self::Data>;

    /// Automatically discards the generated data.
    fn parse_always_nodata(&self, st: CursorStart<'a>) -> CursorLen<'a, ()> {
        self.parse_always(st).map_data(|_| ())
    }

    /// Sets a specific error type.
    fn set_error<E>(self) -> SetError<E, Self>
    where
        Self: Sized,
    {
        SetError(self, core::marker::PhantomData)
    }
}

impl<'a, D, DI> From<CursorData<'a, D>> for CursorLen<'a, DI>
where
    D: Into<DI>,
{
    fn from(v: CursorData<'a, D>) -> Self {
        Self {
            this: CursorData {
                view: v.view,
                pos: v.pos,
                data: v.data.into(),
            },
            len: 0,
        }
    }
}
impl<'a> From<CursorStart<'a>> for CursorLen<'a, ()> {
    fn from(v: CursorStart<'a>) -> Self {
        v.0.into()
    }
}

impl<'a> From<&'a str> for CursorLen<'a, ()> {
    fn from(s: &'a str) -> Self {
        Self {
            len: 0,
            this: CursorData {
                data: (),
                view: s,
                pos: Position::new_zero(),
            },
        }
    }
}
impl<'a, D> CursorLen<'a, D> {
    /// Evaluate the current position of the cursor.
    pub const fn get_pos(self) -> (Position, Self) {
        (self.this.pos, self)
    }
    /// Returns the remaining string.
    pub const fn get_view(self) -> (&'a str, Self) {
        (self.this.view, self)
    }
    /// Applies a function to the saved data without modifying other fields.
    pub fn map_data<DD, F: FnOnce(D) -> DD>(self, f: F) -> CursorLen<'a, DD> {
        CursorLen {
            len: self.len,
            this: CursorData {
                view: self.this.view,
                pos: self.this.pos,
                data: f(self.this.data),
            },
        }
    }
    /// Like [`map_data`] but it may fail.
    #[allow(clippy::missing_errors_doc)]
    pub fn try_map_data<DD, E, F: FnOnce(D) -> Result<DD, E>>(
        self,
        f: F,
    ) -> Result<CursorLen<'a, DD>, E> {
        Ok(CursorLen {
            len: self.len,
            this: CursorData {
                view: self.this.view,
                pos: self.this.pos,
                data: f(self.this.data)?,
            },
        })
    }
    /// Like [`map_data`] but it may fail.
    pub fn opt_map_data<DD, F: FnOnce(D) -> Option<DD>>(self, f: F) -> Option<CursorLen<'a, DD>> {
        Some(CursorLen {
            len: self.len,
            this: CursorData {
                view: self.this.view,
                pos: self.this.pos,
                data: f(self.this.data)?,
            },
        })
    }
    /// Moves stored data outside.
    pub fn get_data(self) -> (D, CursorLen<'a, ()>) {
        (
            self.this.data,
            CursorLen {
                len: self.len,
                this: CursorData {
                    view: self.this.view,
                    pos: self.this.pos,
                    data: (),
                },
            },
        )
    }
    /// Match a `Tool` and replace stored data with returned data.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain_replace<T>(self, t: &T) -> Result<CursorLen<'a, T::Data>, T::Error>
    where
        T: Tool<'a> + ?Sized,
    {
        self.chain_map(t, |_, b, _| b)
    }
    /// Match a `Tool` but discards returned data.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain_nodata<T>(self, t: &T) -> Result<Self, T::Error>
    where
        T: Tool<'a> + ?Sized,
    {
        self.chain_map(t, |a, _, _| a)
    }
    /// Match a `Tool` and keeps both saved and returned data.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain_save<T>(self, t: &T) -> Result<CursorLen<'a, (D, T::Data)>, T::Error>
    where
        T: Tool<'a> + ?Sized,
    {
        self.chain_map(t, |a, b, _| (a, b))
    }
    /// Match a `Tool` and keeps returned data separated from original data.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain_save_out<T>(self, t: &T) -> Result<(Self, T::Data), T::Error>
    where
        T: Tool<'a> + ?Sized,
    {
        let ret = self.chain_save(t)?;
        Ok((
            CursorLen {
                len: ret.len,
                this: CursorData {
                    view: ret.this.view,
                    pos: ret.this.pos,
                    data: ret.this.data.0,
                },
            },
            ret.this.data.1,
        ))
    }
    /// Match a `Tool` and saves returned data at a different location.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain_save_at<T>(self, t: &T, to: &mut T::Data) -> Result<Self, T::Error>
    where
        T: Tool<'a> + ?Sized,
    {
        self.chain_map(t, |a, b, _| {
            *to = b;
            a
        })
    }
    pub(crate) fn chain_map<T, F, O>(self, t: &T, f: F) -> Result<CursorLen<'a, O>, T::Error>
    where
        T: Tool<'a> + ?Sized,
        F: FnOnce(D, T::Data, usize) -> O,
    {
        let c = CursorStart(CursorData {
            view: self.this.view,
            pos: self.this.pos,
            data: (),
        });
        t.parse(c).map(|cnew| CursorLen {
            len: self.len + cnew.len,
            this: CursorData {
                view: cnew.this.view,
                pos: cnew.this.pos,
                data: f(self.this.data, cnew.this.data, cnew.len),
            },
        })
    }
    /// Match an `AlwaysTool` and replace stored data with returned data.
    #[allow(clippy::missing_errors_doc)]
    pub fn always_replace<T>(self, t: &T) -> CursorLen<'a, T::Data>
    where
        T: AlwaysTool<'a> + ?Sized,
    {
        self.always_map(t, |_, b, _| b)
    }
    /// Match an `AlwaysTool` but discards returned data.
    #[allow(clippy::missing_errors_doc)]
    #[must_use]
    pub fn always_nodata<T>(self, t: &T) -> Self
    where
        T: AlwaysTool<'a> + ?Sized,
    {
        self.always_map(t, |a, _, _| a)
    }
    /// Match an `AlwaysTool` and keeps both saved and returned data.
    #[allow(clippy::missing_errors_doc)]
    pub fn always_save<T>(self, t: &T) -> CursorLen<'a, (D, T::Data)>
    where
        T: AlwaysTool<'a> + ?Sized,
    {
        self.always_map(t, |a, b, _| (a, b))
    }
    /// Match an `AlwaysTool` and keeps returned data separated from original data.
    #[allow(clippy::missing_errors_doc)]
    pub fn always_save_out<T>(self, t: &T) -> (Self, T::Data)
    where
        T: AlwaysTool<'a> + ?Sized,
    {
        let ret = self.always_save(t);
        (
            CursorLen {
                len: ret.len,
                this: CursorData {
                    view: ret.this.view,
                    pos: ret.this.pos,
                    data: ret.this.data.0,
                },
            },
            ret.this.data.1,
        )
    }
    /// Match an `AlwaysTool` and saves returned data at a different location.
    #[allow(clippy::missing_errors_doc)]
    #[must_use]
    pub fn always_save_at<T>(self, t: &T, to: &mut T::Data) -> Self
    where
        T: AlwaysTool<'a> + ?Sized,
    {
        self.always_map(t, |a, b, _| {
            *to = b;
            a
        })
    }
    pub(crate) fn always_map<T, F, O>(self, t: &T, f: F) -> CursorLen<'a, O>
    where
        T: AlwaysTool<'a> + ?Sized,
        F: FnOnce(D, T::Data, usize) -> O,
    {
        let c = CursorStart(CursorData {
            view: self.this.view,
            pos: self.this.pos,
            data: (),
        });
        let cnew = t.parse_always(c);
        CursorLen {
            len: self.len + cnew.len,
            this: CursorData {
                view: cnew.this.view,
                pos: cnew.this.pos,
                data: f(self.this.data, cnew.this.data, cnew.len),
            },
        }
    }
}

impl<'a> CursorStart<'a> {
    /// Convert it into a [`CursorLen`]
    #[must_use]
    pub fn into_clen(self) -> CursorLen<'a, ()> {
        self.into()
    }
}
impl<'a> CursorLen<'a, ()> {
    /// Match a [`Tool`](crate::prelude::Tool) object.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain<T>(self, t: &T) -> Result<CursorLen<'a, T::Data>, T::Error>
    where
        T: Tool<'a> + ?Sized,
    {
        self.chain_replace(t)
    }
    /// Match an [`AlwaysTool`] object.
    pub fn always<T>(self, t: &T) -> CursorLen<'a, T::Data>
    where
        T: AlwaysTool<'a> + ?Sized,
    {
        self.always_replace(t)
    }
    /// On error, return the initial `Cursor` instead of the error.
    #[allow(clippy::missing_errors_doc)]
    pub fn chain_err<T>(self, t: &T) -> Result<CursorLen<'a, T::Data>, Self>
    where
        T: Tool<'a> + ?Sized,
    {
        self.chain(t).map_err(|_| self)
    }
}

impl<'a> View<'a> {
    /// Creates a new [`View`] object from a string.
    ///
    /// The initial position is set at line `0` and column `0`.
    #[must_use]
    pub const fn new(view: &'a str) -> Self {
        Self {
            view,
            pos: Position::new_zero(),
        }
    }
    /// Returns the underlying string.
    #[must_use]
    pub const fn get_view(&self) -> &'a str {
        self.view
    }
    /// Tests if the underlying string is empty.
    #[must_use]
    pub const fn is_empty(&self) -> bool {
        self.view.is_empty()
    }
    /// Returns the position of the first character with respect to the main file.
    #[must_use]
    pub const fn top_position(&self) -> &Position {
        &self.pos
    }
    /// Consumes the view and returns the actual [`Position`].
    #[must_use]
    pub const fn into_pos(self) -> Position {
        self.pos
    }
}

/// Tool that returns the matched string as data instead of data provided by inner tool.
#[derive(Debug, Clone, Copy, Default)]
pub struct GetStr<T>(pub T);

impl<'a, T> Tool<'a> for GetStr<T>
where
    T: Tool<'a>,
{
    type Data = &'a str;
    type Error = T::Error;

    fn parse(&self, c: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        let cnew = c.into_clen().chain_nodata(&self.0)?;
        let l = cnew.len;
        Ok(cnew.map_data(|()| &c.0.view[0..l]))
    }
}
impl<'a, T> AlwaysTool<'a> for GetStr<T>
where
    T: AlwaysTool<'a>,
{
    fn parse_always(&self, c: CursorStart<'a>) -> CursorLen<'a, Self::Data> {
        let cnew = c.into_clen().always_nodata(&self.0);
        let l = cnew.len;
        cnew.map_data(|()| &c.0.view[0..l])
    }
}

/// Automatically implements [`Tool`] for an object without templates implementing [`AlwaysTool`].
#[macro_export]
macro_rules! always_impl {
    ($i:ident) => {
        always_impl!($i, ());
    };
    ($i:ident, $t:ty) => {
        impl<'a> Tool<'a> for $i {
            type Error = core::convert::Infallible;
            type Data = $t;

            fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
                Ok(self.parse_always(st))
            }
        }
    };
}

impl<'a, T> Tool<'a> for &T
where
    T: Tool<'a> + ?Sized,
{
    type Error = T::Error;
    type Data = T::Data;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        T::parse(*self, st)
    }
}
impl<'a, T> AlwaysTool<'a> for &T
where
    T: AlwaysTool<'a> + ?Sized,
{
    fn parse_always(&self, st: CursorStart<'a>) -> CursorLen<'a, Self::Data> {
        T::parse_always(*self, st)
    }
}

/// Wrapper for [`AlwaysTool`] objects that sets a different error type.
#[derive(Debug)]
pub struct SetError<E, T>(pub T, pub core::marker::PhantomData<fn() -> E>);

impl<E, T: Clone> Clone for SetError<E, T> {
    fn clone(&self) -> Self {
        Self(self.0.clone(), core::marker::PhantomData)
    }
}
impl<E, T: Copy> Copy for SetError<E, T> {}
impl<E, T: Default> Default for SetError<E, T> {
    fn default() -> Self {
        Self(T::default(), core::marker::PhantomData)
    }
}
impl<'a, E, T> Tool<'a> for SetError<E, T>
where
    T: AlwaysTool<'a>,
{
    type Data = T::Data;
    type Error = E;

    fn parse(&self, c: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        Ok(self.0.parse_always(c))
    }
}

/// Wrapper for [`Tool`] objects that applies a closure to returned data.
#[derive(Debug)]
pub struct MapData<D, T, CD>(pub T, pub CD, pub core::marker::PhantomData<fn() -> D>);

impl<D, CD: Clone, T: Clone> Clone for MapData<D, T, CD> {
    fn clone(&self) -> Self {
        Self(self.0.clone(), self.1.clone(), core::marker::PhantomData)
    }
}
impl<D, CD: Copy, T: Copy> Copy for MapData<D, T, CD> {}
impl<D, CD: Default, T: Default> Default for MapData<D, T, CD> {
    fn default() -> Self {
        Self(T::default(), CD::default(), core::marker::PhantomData)
    }
}
impl<'a, D, CD, T> Tool<'a> for MapData<D, T, CD>
where
    T: Tool<'a>,
    CD: Fn(T::Data) -> D,
{
    type Data = D;
    type Error = T::Error;

    fn parse(&self, c: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        self.0.parse(c).map(|d| d.map_data(&self.1))
    }
}

/// Matches any single character.
///
/// It is exactly the opposite of [`EOFTool`].
#[derive(Debug, Copy, Clone, Default)]
pub struct AnyChar;

impl<'a> Tool<'a> for AnyChar {
    type Data = char;
    type Error = Cursor<'a>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        st.0.view.chars().next().map_or_else(
            || Err(Cursor::from(st)),
            |c| {
                let (_, pos, view) = progress(st.0.pos, st.0.view, c.len_utf8());
                Ok(CursorLen {
                    len: c.len_utf8(),
                    this: CursorData { data: c, pos, view },
                })
            },
        )
    }
}

/// Matches exactly the first character.
impl<'a> Tool<'a> for char {
    type Error = Cursor<'a>;
    type Data = Self;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        AnyChar.parse(st).and_then(|ret| {
            if ret.this.data == *self {
                Ok(ret)
            } else {
                Err(Cursor::from(st))
            }
        })
    }
}

/// Matches exactly the string prefix.
impl<'a> Tool<'a> for str {
    type Error = Cursor<'a>;
    #[allow(clippy::needless_borrows_for_generic_args, clippy::use_self)]
    type Data = &'a str;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        if st.0.view.starts_with(self) {
            let (_, pos, view) = progress(st.0.pos, st.0.view, self.len());
            Ok(CursorLen {
                len: self.len(),
                this: CursorData {
                    data: &st.0.view[0..self.len()],
                    view,
                    pos,
                },
            })
        } else {
            Err(Cursor::from(st))
        }
    }
}

/// Matches any tool in the given slice.
///
/// Tools are evaluated with increasing index ordering, so a later tool would not be tested is a
/// previous tool has already matched.
impl<'a, T> Tool<'a> for [T]
where
    T: Tool<'a>,
{
    type Data = (usize, T::Data);
    /// Only the last error is returned.
    ///
    /// If you want to keep track of every returned error, use instead multiple nested instances of
    /// [`Or`](crate::moretools::Or) tool.
    type Error = Option<T::Error>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        let mut err = None;

        for (i, t) in self.iter().enumerate() {
            match t.parse(st) {
                Ok(r) => return Ok(r.map_data(|d| (i, d))),
                Err(e) => err = Some(e),
            }
        }
        Err(err)
    }
}

/// Matches any tool in the given array.
///
/// Tools are evaluated with increasing index ordering, so a later tool would not be tested is a
/// previous tool has already matched.
impl<'a, T, const N: usize> Tool<'a> for [T; N]
where
    T: Tool<'a>,
{
    type Data = (usize, T::Data);
    /// Only the last error is returned.
    ///
    /// If you want to keep track of every returned error, use instead multiple nested instances of
    /// [`Or`](crate::moretools::Or) tool.
    type Error = Option<T::Error>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        let mut err = None;

        for (i, t) in self.iter().enumerate() {
            match t.parse(st) {
                Ok(r) => return Ok(r.map_data(|d| (i, d))),
                Err(e) => err = Some(e),
            }
        }
        Err(err)
    }
}

/// A tool that matches the empty prefix.
#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
pub struct TrueTool;

impl<'a> AlwaysTool<'a> for TrueTool {
    fn parse_always(&self, st: CursorStart<'a>) -> CursorLen<'a, Self::Data> {
        st.into()
    }
}
always_impl!(TrueTool);

/// Tool that matches characters satisfying a predicate.
#[derive(Debug, Clone, Copy)]
pub struct Predicate<P> {
    pub(crate) predicate: P,
}

impl<P> Predicate<P> {
    /// Create a new [`Predicate`] from a predicate.
    pub const fn new(predicate: P) -> Self {
        Self { predicate }
    }
}

impl<'a, P: Fn(char) -> bool> Tool<'a> for Predicate<P> {
    type Data = char;
    type Error = Cursor<'a>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        AnyChar.parse(st).and_then(|ret| {
            if (self.predicate)(ret.this.data) {
                Ok(ret)
            } else {
                Err(st.into())
            }
        })
    }
}
/// Tool that matches characters satisfying a predicate that also transform the matched character.
#[derive(Debug, Clone, Copy)]
pub struct PredicateData<P> {
    pub(crate) predicate: P,
}

impl<P> PredicateData<P> {
    /// Create a new [`PredicateData`] from a predicate.
    pub const fn new(predicate: P) -> Self {
        Self { predicate }
    }
}

impl<'a, D, P: Fn(char) -> Option<D>> Tool<'a> for PredicateData<P> {
    type Data = (D, usize);
    type Error = Cursor<'a>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        AnyChar.parse(st).and_then(|ret| {
            ret.try_map_data(|c| {
                (self.predicate)(c)
                    .map(|d| (d, c.len_utf8()))
                    .ok_or_else(|| st.into())
            })
        })
    }
}

/// Parses only the end of the input.
///
/// ```rust
/// use minparser::prelude::*;
/// let st = Cursor::from("My data ");
/// st.chain(&"My data ").unwrap().chain_nodata(&EOFTool).unwrap();
/// ```
#[derive(Debug, Clone, Copy, Default)]
pub struct EOFTool;

impl<'a> Tool<'a> for EOFTool {
    type Data = ();
    type Error = CursorStart<'a>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        if st.0.view.is_empty() {
            Ok(st.into())
        } else {
            Err(st)
        }
    }
}

/// Discards empty strings from a match.
///
/// Some atoms that needs to match an undefined number of other atoms (like
/// [`Repeat`](crate::prelude::Repeat) or [`LazyRepeat`](crate::prelude::LazyRepeat))
/// may enter in an infinite loop if the inner atom matches an empty string `""`.
/// In that case there is always a match but the atom does not progress, resulting so in an
/// endless cycle.
///
/// This tool takes another tool and converts any match with an empty string with a missing match,
/// avoiding this issue.
#[derive(Debug, Clone, Copy, Default)]
pub struct NonEmpty<P>(pub P);

impl<'a, P> Tool<'a> for NonEmpty<P>
where
    P: Tool<'a>,
{
    type Data = P::Data;
    type Error = Option<P::Error>;

    fn parse(&self, st: CursorStart<'a>) -> Result<CursorLen<'a, Self::Data>, Self::Error> {
        self.0
            .parse(st)
            .map_err(Some)
            .and_then(|d| if d.len > 0 { Ok(d) } else { Err(None) })
    }
}