postgres-websockets-0.11.2.4: src/APrelude.hs

module APrelude
  ( Text,
    ByteString,
    LByteString,
    Generic,
    fromMaybe,
    putErrLn,
    fromRight,
    isJust,
    decodeUtf8,
    encodeUtf8,
    MVar,
    readMVar,
    swapMVar,
    newMVar,
    STM,
    atomically,
    ThreadId,
    forkFinally,
    forkIO,
    killThread,
    threadDelay,
    (>=>),
    when,
    forever,
    void,
    panic,
    SomeException,
    throwError,
    liftIO,
    runExceptT,
    unpack,
    pack,
    showText,
    showBS,
    LBS.fromStrict,
    stdin,
    stdout,
    stderr,
    hPutStrLn,
    Word16,
    forM,
    forM_,
    takeMVar,
    newEmptyMVar,
    wait,
    headDef,
    tailSafe,
    withAsync,
    putMVar,
    die,
    myThreadId,
    replicateM,
    bracket,
  )
where

import Control.Concurrent (ThreadId, forkFinally, forkIO, killThread, myThreadId, threadDelay)
import Control.Concurrent.Async (wait, withAsync)
import Control.Concurrent.MVar (MVar, newEmptyMVar, newMVar, putMVar, readMVar, swapMVar, takeMVar)
import Control.Concurrent.STM (STM, atomically)
import Control.Exception (Exception, SomeException, bracket, throw)
import Control.Monad (forM, forM_, forever, replicateM, void, when, (>=>))
import Control.Monad.Error.Class (throwError)
import Control.Monad.Except (runExceptT)
import Control.Monad.IO.Class (liftIO)
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy as LBS
import Data.Either (fromRight)
import Data.Maybe (fromMaybe, isJust, listToMaybe)
import Data.Text (Text, pack, unpack)
import qualified Data.Text as T
import Data.Text.Encoding
import Data.Word (Word16)
import GHC.Generics (Generic)
import System.Exit (die)
import System.IO (hPutStrLn, stderr, stdin, stdout)

showBS :: (Show a) => a -> BS.ByteString
showBS = BS.pack . show

showText :: (Show a) => a -> Text
showText = T.pack . show

type LByteString = LBS.ByteString

-- | Uncatchable exceptions thrown and never caught.
newtype FatalError = FatalError {fatalErrorMessage :: Text}
  deriving (Show)

instance Exception FatalError

panic :: Text -> a
panic a = throw (FatalError a)

putErrLn :: Text -> IO ()
putErrLn = hPutStrLn stderr . unpack

headDef :: a -> [a] -> a
headDef def = fromMaybe def . listToMaybe

tailSafe :: [a] -> [a]
tailSafe = drop 1