LDAPv3-0.1.1.0: src/Common.hs

{-# OPTIONS_GHC -fno-warn-dodgy-imports #-}

module Common (module Common, module X) where

import           Control.Applicative   as X
import           Control.DeepSeq       as X (NFData (rnf))
import           Control.Exception     as X (ArithException (Overflow, Underflow), throw)
import           Control.Monad         as X
import           Control.Newtype       as X (Newtype (..))
import           Data.Bits             as X
import           Data.ByteString       as X (ByteString)
import           Data.ByteString.Short as X (ShortByteString)
import           Data.Foldable         as X (asum)
import           Data.Functor.Identity as X
import           Data.Int              as X
import           Data.IntCast          as X
import           Data.List.NonEmpty    as X (NonEmpty (..), (<|))
import           Data.Maybe            as X
import           Data.Proxy            as X (Proxy (Proxy))
import           Data.Semigroup        as X
import           Data.Text             as X (Text)
import           Data.Text.Short       as X (ShortText)
import           Data.Word             as X
import           GHC.Generics          as X (Generic)
import           GHC.TypeLits          as X hiding (Text)
import           Numeric.Natural       as X (Natural)

import qualified Text.Parsec           as P

{-# INLINE rwhnf #-}
rwhnf :: a -> ()
rwhnf x = seq x ()

{-# INLINE inside #-}
inside :: Ord a => a -> (a, a) -> Bool
x `inside` (lb,ub)
  | lb > ub = error "inside: unsatifiable range"
  | otherwise = lb <= x && x <= ub

impossible :: a
impossible = error "The impossible just happened!"

sepBy1' :: P.Stream s m t => P.ParsecT s u m a -> P.ParsecT s u m sep -> P.ParsecT s u m (NonEmpty a)
sepBy1' p set = f <$> P.sepBy1 p set
  where
    f []     = impossible
    f (x:xs) = x:|xs