module Intro (
Data.Function.const
, Data.Function.flip
, (Data.Function.$)
, (Prelude.$!)
, (Data.Function.&)
, Data.Function.fix
, Data.Function.on
, (.:)
, Prelude.until
, Prelude.asTypeOf
, Prelude.seq
, Data.Void.Void
, Data.Bool.Bool(False, True)
, (Data.Bool.&&)
, (Data.Bool.||)
, Data.Bool.bool
, Data.Bool.not
, Data.Bool.otherwise
, Data.Maybe.Maybe(Nothing, Just)
, Data.Maybe.catMaybes
, Data.Maybe.fromMaybe
, (?:)
, Data.Maybe.isJust
, Data.Maybe.isNothing
, Data.Maybe.mapMaybe
, Data.Maybe.maybe
, Intro.Trustworthy.IsList(
Item
, fromList
)
, convertList
, fromFoldable
, Data.List.break
, Data.List.Extra.breakOn
, Data.List.Extra.breakOnEnd
, Data.List.drop
, Data.List.Extra.dropEnd
, Data.List.dropWhile
, Data.List.dropWhileEnd
, Data.List.filter
, Data.List.group
, Data.List.groupBy
, Data.List.Extra.groupOn
, Data.List.Extra.groupSort
, Data.List.Extra.groupSortBy
, Data.List.Extra.groupSortOn
, Data.List.inits
, Data.List.intercalate
, Data.List.intersperse
, Data.List.isPrefixOf
, Data.List.isSuffixOf
, Data.List.iterate
, Data.List.lookup
, Data.List.Extra.nubOrd
, Data.List.Extra.nubOrdBy
, Data.List.Extra.nubOrdOn
, Data.List.permutations
, Data.List.repeat
, Data.List.replicate
, Data.List.reverse
, Data.List.scanl
, Data.List.scanr
, Data.List.sort
, Data.List.sortBy
, Data.List.sortOn
, Data.List.span
, Data.List.Extra.spanEnd
, Data.List.splitAt
, Data.List.Extra.split
, Data.List.Extra.splitOn
, Data.List.subsequences
, Data.List.tails
, Data.List.take
, Data.List.Extra.takeEnd
, Data.List.takeWhile
, Data.List.transpose
, Data.List.unfoldr
, Data.List.unzip
, Data.List.unzip3
, Data.List.zip
, Data.List.zip3
, Data.List.zipWith
, Data.List.zipWith3
, Safe.headDef
, Safe.headMay
, Safe.initDef
, Safe.initMay
, Safe.lastDef
, Safe.lastMay
, Safe.tailDef
, Safe.tailMay
, Safe.cycleMay
, Safe.cycleDef
, Data.List.NonEmpty.NonEmpty((:|))
, Data.List.NonEmpty.scanl1
, Data.List.NonEmpty.scanr1
, Data.Tuple.fst
, Data.Tuple.snd
, Data.Tuple.curry
, Data.Tuple.uncurry
, Data.Tuple.swap
, Data.Either.Either(Left, Right)
, Data.Either.either
, Data.Either.Extra.fromLeft
, Data.Either.Extra.fromRight
, Data.Either.isLeft
, Data.Either.isRight
, Data.Either.lefts
, Data.Either.rights
, Data.Either.partitionEithers
, Data.Either.Extra.eitherToMaybe
, Data.Either.Extra.maybeToEither
, Data.Char.Char
, Data.String.String
, Data.Text.Text
, LText
, Data.ByteString.ByteString
, LByteString
, Data.String.IsString(fromString)
, Intro.ConvertString.ConvertString(convertString)
, Intro.ConvertString.EncodeString(encodeString, decodeString, decodeStringLenient)
, Lenient(..)
, Data.Map.Map
, Data.Set.Set
, Data.IntMap.IntMap
, Data.IntSet.IntSet
, Data.HashMap.Strict.HashMap
, Data.HashSet.HashSet
, Data.Hashable.Hashable(hash, hashWithSalt)
, Intro.Trustworthy.Hashable1
, Intro.Trustworthy.Hashable2
, Data.Sequence.Seq
, Intro.Trustworthy.DList
, Prelude.Integer
, Numeric.Natural.Natural
, Data.Int.Int
, Data.Int.Int8
, Data.Int.Int16
, Data.Int.Int32
, Data.Int.Int64
, Data.Word.Word
, Data.Word.Word8
, Data.Word.Word16
, Data.Word.Word32
, Data.Word.Word64
, Prelude.Float
, Prelude.Double
, Data.Ratio.Ratio
, Data.Ratio.Rational
, (Data.Ratio.%)
, Data.Ratio.numerator
, Data.Ratio.denominator
, Data.Ratio.approxRational
, Prelude.Num((+), (), (*), negate, abs, signum, fromInteger)
, Prelude.subtract
, (Prelude.^)
, Prelude.Real(toRational)
, Prelude.realToFrac
, Prelude.Integral(quot, rem, div, mod, quotRem, divMod, toInteger)
, Prelude.fromIntegral
, Prelude.even
, Prelude.odd
, Prelude.Fractional((/), recip, fromRational)
, (Prelude.^^)
, Prelude.Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh)
, Prelude.RealFrac(properFraction, truncate, round, ceiling, floor)
, Prelude.RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
encodeFloat, exponent, significand, scaleFloat, isNaN,
isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2)
, Data.Bits.Bits((.&.), (.|.), xor, complement, shift, rotate, zeroBits,
bit, setBit, clearBit, complementBit, testBit,
isSigned,
rotateL, rotateR, popCount)
, Data.Bits.FiniteBits(finiteBitSize, countLeadingZeros, countTrailingZeros)
, Text.Show.Show
#if MIN_VERSION_base(4,9,0)
, Data.Functor.Classes.Show1
, Data.Functor.Classes.Show2
#endif
, show
, showT
, showS
, Text.Read.Read
#if MIN_VERSION_base(4,9,0)
, Data.Functor.Classes.Read1
, Data.Functor.Classes.Read2
#endif
, readMaybe
, Data.Eq.Eq((==), (/=))
#if MIN_VERSION_base(4,9,0)
, Data.Functor.Classes.Eq1
, Data.Functor.Classes.Eq2
#endif
, Data.Ord.Ord(compare, (<), (>), (<=), (>=), max, min)
#if MIN_VERSION_base(4,9,0)
, Data.Functor.Classes.Ord1
, Data.Functor.Classes.Ord2
#endif
, Data.Ord.Ordering(LT,GT,EQ)
, Data.Ord.Down(Down)
, Data.Ord.comparing
, Prelude.Enum(
fromEnum, enumFrom, enumFromThen,
enumFromTo, enumFromThenTo)
, Safe.toEnumMay
, Safe.toEnumDef
, Safe.predMay
, Safe.predDef
, Safe.succMay
, Safe.succDef
, Prelude.Bounded(minBound, maxBound)
, Control.Category.Category(id, (.))
, (Control.Category.<<<)
, (Control.Category.>>>)
, Data.Semigroup.Semigroup((<>), sconcat, stimes)
, Data.Semigroup.First(First, getFirst)
, Data.Semigroup.Last(Last, getLast)
, Data.Semigroup.Min(Min, getMin)
, Data.Semigroup.Max(Max, getMax)
, Data.Semigroup.Option(Option, getOption)
, Data.Monoid.Monoid(mempty, mappend, mconcat)
, Data.Monoid.Dual(Dual, getDual)
, Data.Monoid.Endo(Endo, appEndo)
, Data.Monoid.All(All, getAll)
, Data.Monoid.Any(Any, getAny)
, Data.Monoid.Alt(Alt, getAlt)
, Data.Functor.Functor(
(<$)
)
, (Data.Functor.$>)
, (Data.Functor.<$>)
, map
, Data.Functor.void
, Control.Applicative.Const(Const, getConst)
, Data.Functor.Identity.Identity(Identity, runIdentity)
, Data.Foldable.Foldable(elem, fold, foldMap,
foldr, foldr',
foldl',
product, sum, toList)
, Data.Foldable.null
, Data.Foldable.length
, Data.Foldable.foldrM
, Data.Foldable.foldlM
, Data.Foldable.traverse_
, Data.Foldable.for_
, Data.Foldable.asum
, Data.Foldable.concatMap
, Data.Foldable.all
, Data.Foldable.any
, Data.Foldable.or
, Data.Foldable.and
, Data.Foldable.find
, Data.Foldable.notElem
, Data.Foldable.sequenceA_
, Safe.Foldable.foldl1May
, Safe.Foldable.foldl1Def
, Safe.Foldable.foldr1May
, Safe.Foldable.foldr1Def
, Safe.Foldable.maximumByMay
, Safe.Foldable.maximumByDef
, Safe.Foldable.minimumByMay
, Safe.Foldable.minimumByDef
, Safe.Foldable.maximumMay
, Safe.Foldable.maximumDef
, Safe.Foldable.minimumMay
, Safe.Foldable.minimumDef
, Data.Traversable.Traversable(traverse, sequenceA)
, Data.Traversable.for
, Data.Traversable.mapAccumL
, Data.Traversable.mapAccumR
, Control.Applicative.Applicative(pure, (<*>), (*>), (<*))
, Control.Applicative.ZipList(ZipList, getZipList)
, (Control.Applicative.<**>)
, Control.Applicative.liftA2
, Control.Applicative.liftA3
, skip
, (<>^)
, Control.Applicative.Alternative((<|>), empty, many )
, Control.Applicative.optional
, Data.List.NonEmpty.some1
, Control.Monad.Monad((>>=))
#if MIN_VERSION_base(4,9,0)
, Control.Monad.Fail.MonadFail
#endif
, fail
, Control.Monad.Fix.MonadFix(mfix)
, (Control.Monad.=<<)
, (Control.Monad.<=<)
, (Control.Monad.>=>)
, Control.Monad.MonadPlus(mzero, mplus)
, Control.Monad.join
, Control.Monad.guard
, Control.Monad.when
, Control.Monad.unless
, Control.Monad.replicateM
, Control.Monad.replicateM_
, (Control.Monad.<$!>)
, Control.Monad.Extra.whenM
, Control.Monad.Extra.unlessM
, Control.Monad.Extra.ifM
, Control.Monad.Extra.allM
, Control.Monad.Extra.anyM
, Control.Monad.Extra.andM
, Control.Monad.Extra.orM
, Control.Monad.Extra.concatMapM
, (Control.Monad.Extra.&&^)
, (Control.Monad.Extra.||^)
, Data.Bifunctor.Bifunctor(bimap, first, second)
, Data.Bifoldable.Bifoldable(bifoldr
, bifoldMap)
, Data.Bifoldable.bifoldl'
, Data.Bifoldable.bifoldr'
, Data.Bifoldable.bitraverse_
, Data.Bifoldable.bisequenceA_
, Data.Bifoldable.bifor_
, Data.Bitraversable.Bitraversable(bitraverse)
, Data.Bitraversable.bifor
, Data.Bitraversable.bisequenceA
, Control.Monad.Trans.MonadTrans(lift)
, Control.Monad.Trans.Maybe.MaybeT(MaybeT, runMaybeT)
, Control.Monad.Trans.Maybe.mapMaybeT
, Control.Monad.Except.MonadError(throwError, catchError)
, Control.Monad.Except.Except
, Control.Monad.Except.runExcept
, Control.Monad.Except.mapExcept
, Control.Monad.Except.withExcept
, Control.Monad.Except.ExceptT(ExceptT)
, Control.Monad.Except.runExceptT
, Control.Monad.Except.mapExceptT
, Control.Monad.Except.withExceptT
, Control.Monad.Reader.MonadReader(ask, local, reader)
, Control.Monad.Reader.asks
, Control.Monad.Reader.Reader
, Control.Monad.Reader.runReader
, Control.Monad.Reader.mapReader
, Control.Monad.Reader.withReader
, Control.Monad.Reader.ReaderT(ReaderT, runReaderT)
, Control.Monad.Reader.mapReaderT
, Control.Monad.Reader.withReaderT
, Control.Monad.Writer.CPS.MonadWriter(writer, tell, listen, pass)
, Control.Monad.Writer.CPS.Writer
, Control.Monad.Writer.CPS.runWriter
, Control.Monad.Writer.CPS.execWriter
, Control.Monad.Writer.CPS.mapWriter
, Control.Monad.Writer.CPS.WriterT
, Control.Monad.Writer.CPS.writerT
, Control.Monad.Writer.CPS.runWriterT
, Control.Monad.Writer.CPS.execWriterT
, Control.Monad.Writer.CPS.mapWriterT
, Control.Monad.State.Strict.MonadState(get, put, state)
, Control.Monad.State.Strict.State
, Control.Monad.State.Strict.gets
, Control.Monad.State.Strict.modify
, Control.Monad.State.Strict.modify'
, Control.Monad.State.Strict.runState
, Control.Monad.State.Strict.evalState
, Control.Monad.State.Strict.execState
, Control.Monad.State.Strict.mapState
, Control.Monad.State.Strict.withState
, Control.Monad.State.Strict.StateT(StateT, runStateT)
, Control.Monad.State.Strict.evalStateT
, Control.Monad.State.Strict.execStateT
, Control.Monad.State.Strict.mapStateT
, Control.Monad.State.Strict.withStateT
, Control.Monad.RWS.CPS.MonadRWS
, Control.Monad.RWS.CPS.RWS
, Control.Monad.RWS.CPS.rws
, Control.Monad.RWS.CPS.runRWS
, Control.Monad.RWS.CPS.evalRWS
, Control.Monad.RWS.CPS.execRWS
, Control.Monad.RWS.CPS.mapRWS
, Control.Monad.RWS.CPS.RWST
, Control.Monad.RWS.CPS.rwsT
, Control.Monad.RWS.CPS.runRWST
, Control.Monad.RWS.CPS.evalRWST
, Control.Monad.RWS.CPS.execRWST
, Control.Monad.RWS.CPS.mapRWST
, GHC.Generics.Generic
, GHC.Generics.Generic1
, Data.Typeable.Typeable
, Control.DeepSeq.NFData
, Data.Binary.Binary
#if MIN_VERSION_base(4,9,0)
, Data.Kind.Type
#endif
, Intro.Trustworthy.Constraint
, Data.Proxy.Proxy(Proxy)
, Data.Tagged.Tagged(Tagged)
, Data.Tagged.unTagged
, System.IO.IO
, Control.Monad.Trans.MonadIO(liftIO)
, getChar
, getContents
, getLine
, print
, putChar
, putStr
, putStrLn
, System.IO.FilePath
, readFile
, writeFile
, appendFile
, readFileUtf8
, writeFileUtf8
, appendFileUtf8
, panic
, undefined
, Intro.Trustworthy.trace
, Intro.Trustworthy.traceIO
, Intro.Trustworthy.traceM
, Intro.Trustworthy.traceShow
, Intro.Trustworthy.traceShowM
) where
import Control.Monad.Trans (MonadIO(liftIO))
import Data.ByteString (ByteString)
import Data.Char (Char)
import Data.Function ((.), ($))
import Data.Functor (Functor(fmap))
import Data.Maybe (Maybe, fromMaybe)
import Data.Semigroup (Semigroup((<>)))
import Data.String (IsString(fromString), String)
import Data.Text (Text)
import Intro.ConvertString
import Intro.Trustworthy
import System.IO (FilePath)
import Text.Show (Show)
import qualified Control.Applicative
import qualified Control.Category
import qualified Control.DeepSeq
import qualified Control.Monad
import qualified Control.Monad.Except
import qualified Control.Monad.Extra
import qualified Control.Monad.Fix
import qualified Control.Monad.RWS.CPS
import qualified Control.Monad.Reader
import qualified Control.Monad.State.Strict
import qualified Control.Monad.Trans
import qualified Control.Monad.Trans.Maybe
import qualified Control.Monad.Writer.CPS
import qualified Data.Bifoldable
import qualified Data.Bifunctor
import qualified Data.Binary
import qualified Data.Bitraversable
import qualified Data.Bits
import qualified Data.Bool
import qualified Data.ByteString
import qualified Data.ByteString.Lazy
import qualified Data.Either
import qualified Data.Either.Extra
import qualified Data.Eq
import qualified Data.Foldable
import qualified Data.Function
import qualified Data.Functor
import qualified Data.Functor.Identity
import qualified Data.HashMap.Strict
import qualified Data.HashSet
import qualified Data.Hashable
import qualified Data.Int
import qualified Data.IntMap
import qualified Data.IntSet
import qualified Data.List
import qualified Data.List.Extra
import qualified Data.List.NonEmpty
import qualified Data.Map
import qualified Data.Maybe
import qualified Data.Monoid
import qualified Data.Ord
import qualified Data.Proxy
import qualified Data.Ratio
import qualified Data.Semigroup
import qualified Data.Sequence
import qualified Data.Set
import qualified Data.Tagged
import qualified Data.Text.IO
import qualified Data.Text.Lazy
import qualified Data.Traversable
import qualified Data.Tuple
import qualified Data.Typeable
import qualified Data.Void
import qualified Data.Word
import qualified GHC.Generics
import qualified Numeric.Natural
import qualified Prelude
import qualified Safe
import qualified Safe.Foldable
import qualified System.IO
import qualified Text.Read
import qualified Text.Show
#if MIN_VERSION_base(4,9,0)
import qualified Control.Monad.Fail
import qualified Data.Functor.Classes
import qualified Data.Kind
#endif
type LText = Data.Text.Lazy.Text
type LByteString = Data.ByteString.Lazy.ByteString
fromFoldable :: (Data.Foldable.Foldable f, IsList a) => f (Item a) -> a
fromFoldable = fromList . Data.Foldable.toList
convertList :: (IsList a, IsList b, Item a ~ Item b) => a -> b
convertList = fromList . toList
map :: Functor f => (a -> b) -> f a -> f b
map = fmap
show :: (Show a, ConvertString String s) => a -> s
show = convertString . showS
showT :: Show a => a -> Text
showT = show
showS :: Show a => a -> String
showS = Text.Show.show
readMaybe :: (Text.Read.Read b, ConvertString a String) => a -> Maybe b
readMaybe = Text.Read.readMaybe . convertString
print :: (MonadIO m, Show a) => a -> m ()
print = liftIO . System.IO.print
getContents :: MonadIO m => m Text
getContents = liftIO Data.Text.IO.getContents
getLine :: MonadIO m => m Text
getLine = liftIO Data.Text.IO.getLine
getChar :: MonadIO m => m Char
getChar = liftIO System.IO.getChar
putStr :: MonadIO m => Text -> m ()
putStr = liftIO . Data.Text.IO.putStr
putStrLn :: MonadIO m => Text -> m ()
putStrLn = liftIO . Data.Text.IO.putStrLn
putChar :: MonadIO m => Char -> m ()
putChar = liftIO . System.IO.putChar
readFile :: MonadIO m => FilePath -> m ByteString
readFile = liftIO . Data.ByteString.readFile
writeFile :: MonadIO m => FilePath -> ByteString -> m ()
writeFile = liftIO .: Data.ByteString.writeFile
appendFile :: MonadIO m => FilePath -> ByteString -> m ()
appendFile = liftIO .: Data.ByteString.appendFile
readFileUtf8 :: MonadIO m => FilePath -> m Text
readFileUtf8 = map decodeStringLenient . readFile
writeFileUtf8 :: MonadIO m => FilePath -> Text -> m ()
writeFileUtf8 file = writeFile file . convertString
appendFileUtf8 :: MonadIO m => FilePath -> Text -> m ()
appendFileUtf8 file = appendFile file . convertString
undefined :: HasCallStack => a
undefined = Prelude.undefined
(<>^) :: (Control.Applicative.Applicative f, Semigroup a) => f a -> f a -> f a
(<>^) = Control.Applicative.liftA2 (<>)
infixr 6 <>^
(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
(.:) = (.) . (.)
infixr 8 .:
(?:) :: Maybe a -> a -> a
(?:) = Data.Function.flip fromMaybe
infix 1 ?:
skip :: Control.Applicative.Applicative m => m ()
skip = Control.Applicative.pure ()
panic :: HasCallStack => Text -> a
panic msg = Prelude.error $ convertString $
"Panic: " <> msg <> "\n\n" <>
"Please submit a bug report including the stacktrace\n" <>
"and a description on how to reproduce the bug."
#if MIN_VERSION_base(4,9,0)
fail :: Control.Monad.Fail.MonadFail m => Text -> m a
fail = Control.Monad.Fail.fail . convertString
#else
fail :: Control.Monad.Monad m => Text -> m a
fail = Control.Monad.fail . convertString
#endif