{-# language NoImplicitPrelude, DoAndIfThenElse, OverloadedStrings, ExtendedDefaultRules #-}
{-# LANGUAGE CPP #-}
module IHaskellPrelude (
  module IHaskellPrelude,
  module X,

  -- Select reexports
  Data.Typeable.Typeable,
  Data.Typeable.cast,

  Data.Typeable.Proxy,

  GHC.Exts.IsString,
  GHC.Exts.IsList,

  System.IO.hPutStrLn,
  System.IO.hPutStr,
  System.IO.hPutChar,
  System.IO.hPrint,
  System.IO.stdout,
  System.IO.stderr,
  System.IO.stdin,
  System.IO.getChar,
  System.IO.getLine,
  System.IO.writeFile,
  System.IO.Handle,

  System.IO.Strict.readFile,
  System.IO.Strict.getContents,
  System.IO.Strict.hGetContents,

  Control.Exception.catch,
  Control.Exception.SomeException,

  Control.Applicative.Applicative(..),
  Control.Applicative.ZipList(..),
  (Control.Applicative.<$>),

  Control.Concurrent.MVar.MVar,
  Control.Concurrent.MVar.newMVar,
  Control.Concurrent.MVar.newEmptyMVar,
  Control.Concurrent.MVar.isEmptyMVar,
  Control.Concurrent.MVar.readMVar,
  Control.Concurrent.MVar.takeMVar,
  Control.Concurrent.MVar.putMVar,
  Control.Concurrent.MVar.modifyMVar,
  Control.Concurrent.MVar.modifyMVar_,

  Data.IORef.IORef,
  Data.IORef.readIORef,
  Data.IORef.writeIORef,
  Data.IORef.modifyIORef',
  Data.IORef.newIORef,



  -- Miscellaneous names
  Data.Map.Map,
  GHC.IO.FilePath,
  Data.Text.Text,
  Data.ByteString.ByteString,
  Text.Printf.printf,
  Data.Function.on,
  ) where

import           Prelude

import           Data.Semigroup         as X
import           Data.Monoid            as X hiding ((<>), First(..), Last(..))
import           Data.Tuple             as X
import           Control.Monad          as X
import           Data.Maybe             as X
import           Data.Either            as X
import           Control.Monad.IO.Class as X
import           Data.Ord               as X
import           GHC.Show               as X
import           GHC.Enum               as X
import           GHC.Num                as X
import           GHC.Real               as X
import           GHC.Err                as X hiding (absentErr)
import           GHC.Base               as X hiding (Any, mapM, foldr, sequence, many, (<|>), Module(..))
import           Data.List              as X hiding (head, last, tail, init, transpose, subsequences, permutations,
                                        foldl, foldl1, maximum, minimum, scanl, scanl1, scanr, scanr1,
                                        span, break, mapAccumL, mapAccumR, dropWhileEnd, (!!),
                                        elemIndices, elemIndex, findIndex, findIndices, zip5, zip6,
                                        zip7, zipWith5, zipWith6, zipWith7, unzip5, unzip6, unzip6,
                                        delete, union, lookup, intersect, insert, deleteBy,
                                        unionBy, intersectBy, group, groupBy, insertBy,
                                        maximumBy, minimumBy, genericLength, genericDrop, genericTake,
                                        genericSplitAt, genericIndex, genericReplicate, inits, tails)

import qualified Control.Applicative
import qualified Data.Typeable
import qualified Data.IORef
import qualified Data.Map
import qualified Data.Text
import qualified Data.Text.Lazy
import qualified Data.ByteString
import qualified Data.ByteString.Lazy
import qualified Data.Function
import qualified Data.List.NonEmpty
import qualified GHC.Exts
import qualified System.IO
import qualified System.IO.Strict
import qualified GHC.IO
import qualified Text.Printf
import qualified Control.Exception
import qualified Control.Concurrent.MVar

import qualified Data.List
import qualified Prelude as P

type LByteString = Data.ByteString.Lazy.ByteString

type LText = Data.Text.Lazy.Text

headMay :: [a] -> Maybe a
headMay :: forall a. [a] -> Maybe a
headMay = ([a] -> a) -> [a] -> Maybe a
forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> a
forall a. HasCallStack => [a] -> a
head

tailMay :: [a] -> Maybe [a]
tailMay :: forall a. [a] -> Maybe [a]
tailMay = ([a] -> [a]) -> [a] -> Maybe [a]
forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> [a]
forall a. HasCallStack => [a] -> [a]
tail

lastMay :: [a] -> Maybe a
lastMay :: forall a. [a] -> Maybe a
lastMay = ([a] -> a) -> [a] -> Maybe a
forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> a
forall a. HasCallStack => [a] -> a
last

initMay :: [a] -> Maybe [a]
initMay :: forall a. [a] -> Maybe [a]
initMay = ([a] -> [a]) -> [a] -> Maybe [a]
forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> [a]
forall a. HasCallStack => [a] -> [a]
init

maximumMay :: Ord a => [a] -> Maybe a
maximumMay :: forall a. Ord a => [a] -> Maybe a
maximumMay = ([a] -> a) -> [a] -> Maybe a
forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> a
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum

minimumMay :: Ord a => [a] -> Maybe a
minimumMay :: forall a. Ord a => [a] -> Maybe a
minimumMay = ([a] -> a) -> [a] -> Maybe a
forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> a
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum

wrapEmpty :: ([a] -> b) -> [a] -> Maybe b
wrapEmpty :: forall a b. ([a] -> b) -> [a] -> Maybe b
wrapEmpty [a] -> b
_ [] = Maybe b
forall a. Maybe a
Nothing
wrapEmpty [a] -> b
f [a]
xs = b -> Maybe b
forall a. a -> Maybe a
Just ([a] -> b
f [a]
xs)

maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
maximumByMay :: forall a. (a -> a -> Ordering) -> [a] -> Maybe a
maximumByMay a -> a -> Ordering
_ [] = Maybe a
forall a. Maybe a
Nothing
maximumByMay a -> a -> Ordering
f [a]
xs = a -> Maybe a
forall a. a -> Maybe a
Just ((a -> a -> Ordering) -> [a] -> a
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
Data.List.maximumBy a -> a -> Ordering
f [a]
xs)

minimumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
minimumByMay :: forall a. (a -> a -> Ordering) -> [a] -> Maybe a
minimumByMay a -> a -> Ordering
_ [] = Maybe a
forall a. Maybe a
Nothing
minimumByMay a -> a -> Ordering
f [a]
xs = a -> Maybe a
forall a. a -> Maybe a
Just ((a -> a -> Ordering) -> [a] -> a
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
Data.List.minimumBy a -> a -> Ordering
f [a]
xs)

readMay :: Read a => String -> Maybe a
readMay :: forall a. Read a => String -> Maybe a
readMay = ((a, String) -> a) -> Maybe (a, String) -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a, String) -> a
forall a b. (a, b) -> a
fst (Maybe (a, String) -> Maybe a)
-> (String -> Maybe (a, String)) -> String -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(a, String)] -> Maybe (a, String)
forall a. [a] -> Maybe a
headMay ([(a, String)] -> Maybe (a, String))
-> (String -> [(a, String)]) -> String -> Maybe (a, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [(a, String)]
forall a. Read a => ReadS a
reads

putStrLn :: (MonadIO m) => String -> m ()
putStrLn :: forall (m :: * -> *). MonadIO m => String -> m ()
putStrLn = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> (String -> IO ()) -> String -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ()
P.putStrLn

putStr :: (MonadIO m) => String -> m ()
putStr :: forall (m :: * -> *). MonadIO m => String -> m ()
putStr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> (String -> IO ()) -> String -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ()
P.putStr

putChar :: MonadIO m => Char -> m ()
putChar :: forall (m :: * -> *). MonadIO m => Char -> m ()
putChar = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> (Char -> IO ()) -> Char -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> IO ()
P.putChar

print :: (MonadIO m, Show a) => a -> m ()
print :: forall (m :: * -> *) a. (MonadIO m, Show a) => a -> m ()
print = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> (a -> IO ()) -> a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> IO ()
forall a. Show a => a -> IO ()
P.print

nonEmptyToList :: Data.List.NonEmpty.NonEmpty a -> [a]
nonEmptyToList :: forall a. NonEmpty a -> [a]
nonEmptyToList = NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
Data.List.NonEmpty.toList