-- | Extension to the ''Prelude''. module BNFC.Prelude ( module Prelude , module BNFC.Utils.Decoration , module BNFC.Utils.List1 , module BNFC.Utils.List2 , module BNFC.Utils.Singleton , module BNFC.Utils.Panic , module Control.Monad , module Control.Monad.Except , module Control.Monad.Reader , module Control.Monad.State , module Control.Monad.Trans , module Control.Monad.Trans.Control , module Control.Monad.Writer , module Data.Bifunctor , module Data.Char , module Data.Containers.ListUtils , module Data.Either , module Data.Foldable , module Data.Function , module Data.Functor -- , module Data.Functor.Compat , module Data.Maybe , module Data.Semigroup , module Data.Tuple -- , module Data.List.Extra , module Data.List.NonEmpty , module Data.Map , module Data.Set , module Lens.Micro , module Lens.Micro.Mtl , spanEnd , forMM_ ) where -- Keep in order! -- By default, in alphabetical order. import Prelude hiding (exp) import BNFC.Utils.Decoration import BNFC.Utils.List1 ( List1, pattern (:|), (<|), nonEmpty, String1, trim1 ) import BNFC.Utils.List2 ( List2(..) ) import BNFC.Utils.Singleton import BNFC.Utils.Panic import Control.Monad import Control.Monad.Except ( MonadError(..), ExceptT(..), runExceptT ) import Control.Monad.Reader ( MonadReader(..), asks, ReaderT(..), mapReaderT, runReaderT ) import Control.Monad.State ( MonadState(..), gets, modify, StateT(..), evalStateT, execStateT ) import Control.Monad.Trans ( MonadTrans(..), lift ) import Control.Monad.Trans.Control ( MonadTransControl(..), liftThrough ) import Control.Monad.Writer ( MonadWriter(..), WriterT(..), Writer, runWriter ) import Data.Bifunctor import Data.Char import Data.Containers.ListUtils ( nubOrd ) import Data.Either import Data.Foldable ( all, toList ) import Data.Function ( on ) import Data.Functor -- (<&>) is also exported by Lens.Micro -- import Data.Functor.Compat ( (<&>) ) import Data.Maybe import Data.Semigroup ( Semigroup(..) ) import Data.Tuple -- extra: export functions individually -- import Data.List.Extra ( trim ) -- containers: only export types and operators import Data.List.NonEmpty ( pattern (:|), (<|) ) import Data.Map ( Map ) import Data.Set ( Set ) import Lens.Micro import Lens.Micro.Mtl import qualified Data.List.NonEmpty -- * Non-empty lists and their utilities. -- * List utilities -- Note: there is also spanEnd in Data.List.Extra, but this implementation -- seems more efficient. -- | @spanEnd p l == reverse (span p (reverse l))@. -- -- Invariant: @l == front ++ end where (end, front) = spanEnd p l@ -- -- (From package ghc, module Util.) spanEnd :: (a -> Bool) -> [a] -> ([a], [a]) spanEnd p l = go l [] [] l where go yes _ rev_no [] = (yes, reverse rev_no) go yes rev_yes rev_no (x:xs) | p x = go yes (x : rev_yes) rev_no xs | otherwise = go xs [] (x : rev_yes ++ rev_no) xs -- * Monad utilities forMM_ :: (Monad m, Foldable t) => m (t a) -> (a -> m ()) -> m () forMM_ m f = mapM_ f =<< m