    -- |
    -- Module      :  Control.Monad.Combinators.NonEmpty
    -- Copyright   :  © 2017–present Mark Karpov
    -- License     :  BSD 3 clause
    --
    -- Maintainer  :  Mark Karpov <markkarpov92@gmail.com>
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- The module provides 'NonEmpty' list variants of some of the functions
    -- from "Control.Monad.Combinators".
    --
    -- @since 0.4.0
    module Control.Monad.Combinators.NonEmpty
      ( some,
        endBy1,
        someTill,
        sepBy1,
        sepEndBy1,
      )
    where

    import Control.Monad
    import qualified Control.Monad.Combinators as C
    import Data.List.NonEmpty (NonEmpty (..))
    import qualified Data.List.NonEmpty as NE

    -- | @'some' p@ applies the parser @p@ /one/ or more times and returns a
    -- list of the values returned by @p@.
    --
    -- > word = some letter
    some :: MonadPlus m => m a -> m (NonEmpty a)
    some :: forall (m :: * -> *) a. MonadPlus m => m a -> m (NonEmpty a)
    some m a
    p = [a] -> NonEmpty a
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([a] -> NonEmpty a) -> m [a] -> m (NonEmpty a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a -> m [a]
    forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
    C.some m a
    p
    {-# INLINE some #-}

    -- | @'endBy1' p sep@ parses /one/ or more occurrences of @p@, separated and
    -- ended by @sep@. Returns a non-empty list of values returned by @p@.
    endBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)
    endBy1 :: forall (m :: * -> *) a sep.
    MonadPlus m =>
    m a -> m sep -> m (NonEmpty a)
    endBy1 m a
    p m sep
    sep = [a] -> NonEmpty a
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([a] -> NonEmpty a) -> m [a] -> m (NonEmpty a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a -> m sep -> m [a]
    forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
    C.endBy1 m a
    p m sep
    sep
    {-# INLINE endBy1 #-}

    -- | @'someTill' p end@ works similarly to @'C.manyTill' p end@, but @p@
    -- should succeed at least once.
    --
    -- See also: 'C.skipSome', 'C.skipSomeTill'.
    someTill :: MonadPlus m => m a -> m end -> m (NonEmpty a)
    someTill :: forall (m :: * -> *) a sep.
    MonadPlus m =>
    m a -> m sep -> m (NonEmpty a)
    someTill m a
    p m end
    end = [a] -> NonEmpty a
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([a] -> NonEmpty a) -> m [a] -> m (NonEmpty a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a -> m end -> m [a]
    forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
    C.someTill m a
    p m end
    end
    {-# INLINE someTill #-}

    -- | @'sepBy1' p sep@ parses /one/ or more occurrences of @p@, separated by
    -- @sep@. Returns a non-empty list of values returned by @p@.
    sepBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)
    sepBy1 :: forall (m :: * -> *) a sep.
    MonadPlus m =>
    m a -> m sep -> m (NonEmpty a)
    sepBy1 m a
    p m sep
    sep = [a] -> NonEmpty a
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([a] -> NonEmpty a) -> m [a] -> m (NonEmpty a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a -> m sep -> m [a]
    forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
    C.sepBy1 m a
    p m sep
    sep
    {-# INLINE sepBy1 #-}

    -- | @'sepEndBy1' p sep@ parses /one/ or more occurrences of @p@, separated
    -- and optionally ended by @sep@. Returns a non-empty list of values returned by
    -- @p@.
    sepEndBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)
    sepEndBy1 :: forall (m :: * -> *) a sep.
    MonadPlus m =>
    m a -> m sep -> m (NonEmpty a)
    sepEndBy1 m a
    p m sep
    sep = [a] -> NonEmpty a
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([a] -> NonEmpty a) -> m [a] -> m (NonEmpty a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m a -> m sep -> m [a]
    forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
    C.sepEndBy1 m a
    p m sep
    sep
    {-# INLINE sepEndBy1 #-}