intro 0.0.1.0 → 0.0.2.0
raw patch · 3 files changed
+728/−703 lines, 3 filesPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
- Intro.Trustworthy: trace :: Text -> a -> a
- Intro.Trustworthy: traceIO :: Text -> IO ()
- Intro.Trustworthy: traceM :: Monad m => Text -> m ()
- Intro.Trustworthy: traceShow :: Show a => a -> b -> b
- Intro.Trustworthy: traceShowM :: (Show a, Monad m) => a -> m ()
- Intro.Trustworthy: traceStack :: Text -> a -> a
- Intro.Trustworthy: traceStackM :: Monad m => Text -> m ()
+ Intro: ($!) :: (a -> b) -> a -> b
+ Intro: ($) :: (a -> b) -> a -> b
+ Intro: ($>) :: Functor f => f a -> b -> f b
+ Intro: (%) :: Integral a => a -> a -> Ratio a
+ Intro: (&&) :: Bool -> Bool -> Bool
+ Intro: (&&^) :: Monad m => m Bool -> m Bool -> m Bool
+ Intro: (&) :: a -> (a -> b) -> b
+ Intro: (*) :: Num a => a -> a -> a
+ Intro: (**) :: Floating a => a -> a -> a
+ Intro: (*>) :: Applicative f => f a -> f b -> f b
+ Intro: (+) :: Num a => a -> a -> a
+ Intro: (-) :: Num a => a -> a -> a
+ Intro: (.&.) :: Bits a => a -> a -> a
+ Intro: (.) :: Category k cat => cat b c -> cat a b -> cat a c
+ Intro: (.|.) :: Bits a => a -> a -> a
+ Intro: (/) :: Fractional a => a -> a -> a
+ Intro: (/=) :: Eq a => a -> a -> Bool
+ Intro: (:|) :: a -> [a] -> NonEmpty a
+ Intro: (<$!>) :: Monad m => (a -> b) -> m a -> m b
+ Intro: (<$) :: Functor f => a -> f b -> f a
+ Intro: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ Intro: (<) :: Ord a => a -> a -> Bool
+ Intro: (<*) :: Applicative f => f a -> f b -> f a
+ Intro: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
+ Intro: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ Intro: (<<<) :: Category k cat => cat b c -> cat a b -> cat a c
+ Intro: (<=) :: Ord a => a -> a -> Bool
+ Intro: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ Intro: (<>) :: Semigroup a => a -> a -> a
+ Intro: (<|>) :: Alternative f => f a -> f a -> f a
+ Intro: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ Intro: (==) :: Eq a => a -> a -> Bool
+ Intro: (>) :: Ord a => a -> a -> Bool
+ Intro: (>=) :: Ord a => a -> a -> Bool
+ Intro: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ Intro: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ Intro: (>>>) :: Category k cat => cat a b -> cat b c -> cat a c
+ Intro: (^) :: (Num a, Integral b) => a -> b -> a
+ Intro: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Intro: (||) :: Bool -> Bool -> Bool
+ Intro: (||^) :: Monad m => m Bool -> m Bool -> m Bool
+ Intro: All :: Bool -> All
+ Intro: Alt :: f a -> Alt k
+ Intro: Any :: Bool -> Any
+ Intro: Const :: a -> Const k a
+ Intro: Down :: a -> Down a
+ Intro: Dual :: a -> Dual a
+ Intro: EQ :: Ordering
+ Intro: Endo :: (a -> a) -> Endo a
+ Intro: ExceptT :: m (Either e a) -> ExceptT e a
+ Intro: False :: Bool
+ Intro: First :: a -> First a
+ Intro: GT :: Ordering
+ Intro: Identity :: a -> Identity a
+ Intro: Just :: a -> Maybe a
+ Intro: LT :: Ordering
+ Intro: Last :: a -> Last a
+ Intro: Left :: a -> Either a b
+ Intro: Max :: a -> Max a
+ Intro: MaybeT :: m (Maybe a) -> MaybeT a
+ Intro: Min :: a -> Min a
+ Intro: Nothing :: Maybe a
+ Intro: Option :: Maybe a -> Option a
+ Intro: Proxy :: Proxy k
+ Intro: ReaderT :: (r -> m a) -> ReaderT k r
+ Intro: Right :: b -> Either a b
+ Intro: StateT :: (s -> m (a, s)) -> StateT s a
+ Intro: Tagged :: b -> Tagged k b
+ Intro: True :: Bool
+ Intro: ZipList :: [a] -> ZipList a
+ Intro: [appEndo] :: Endo a -> a -> a
+ Intro: [getAll] :: All -> Bool
+ Intro: [getAlt] :: Alt k -> f a
+ Intro: [getAny] :: Any -> Bool
+ Intro: [getConst] :: Const k a -> a
+ Intro: [getDual] :: Dual a -> a
+ Intro: [getFirst] :: First a -> a
+ Intro: [getLast] :: Last a -> a
+ Intro: [getMax] :: Max a -> a
+ Intro: [getMin] :: Min a -> a
+ Intro: [getOption] :: Option a -> Maybe a
+ Intro: [getZipList] :: ZipList a -> [a]
+ Intro: [runIdentity] :: Identity a -> a
+ Intro: [runMaybeT] :: MaybeT a -> m (Maybe a)
+ Intro: [runReaderT] :: ReaderT k r -> r -> m a
+ Intro: [runStateT] :: StateT s a -> s -> m (a, s)
+ Intro: [unTagged] :: Tagged k b -> b
+ Intro: abs :: Num a => a -> a
+ Intro: acos :: Floating a => a -> a
+ Intro: acosh :: Floating a => a -> a
+ Intro: all :: Foldable t => (a -> Bool) -> t a -> Bool
+ Intro: allM :: Monad m => (a -> m Bool) -> [a] -> m Bool
+ Intro: and :: Foldable t => t Bool -> Bool
+ Intro: andM :: Monad m => [m Bool] -> m Bool
+ Intro: any :: Foldable t => (a -> Bool) -> t a -> Bool
+ Intro: anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool
+ Intro: approxRational :: RealFrac a => a -> a -> Rational
+ Intro: asTypeOf :: a -> a -> a
+ Intro: asin :: Floating a => a -> a
+ Intro: asinh :: Floating a => a -> a
+ Intro: ask :: MonadReader r m => m r
+ Intro: asks :: MonadReader r m => (r -> a) -> m a
+ Intro: asum :: (Foldable t, Alternative f) => t (f a) -> f a
+ Intro: atan :: Floating a => a -> a
+ Intro: atan2 :: RealFloat a => a -> a -> a
+ Intro: atanh :: Floating a => a -> a
+ Intro: bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
+ Intro: bifoldl :: Bifoldable p => (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
+ Intro: bifoldr :: Bifoldable p => (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
+ Intro: bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
+ Intro: bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
+ Intro: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ Intro: bisequenceA :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
+ Intro: bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
+ Intro: bit :: Bits a => Int -> a
+ Intro: bitraverse :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
+ Intro: bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
+ Intro: bool :: a -> a -> Bool -> a
+ Intro: break :: (a -> Bool) -> [a] -> ([a], [a])
+ Intro: catMaybes :: [Maybe a] -> [a]
+ Intro: catchError :: MonadError e m => m a -> (e -> m a) -> m a
+ Intro: ceiling :: (RealFrac a, Integral b) => a -> b
+ Intro: class Applicative f => Alternative (f :: * -> *)
+ Intro: class Functor f => Applicative (f :: * -> *)
+ Intro: class Bifoldable (p :: * -> * -> *)
+ Intro: class Bifunctor (p :: * -> * -> *)
+ Intro: class Binary t
+ Intro: class (Bifunctor t, Bifoldable t) => Bitraversable (t :: * -> * -> *)
+ Intro: class Eq a => Bits a
+ Intro: class Bounded a
+ Intro: class Category k (cat :: k -> k -> *)
+ Intro: class ConvertibleStrings a b
+ Intro: class Enum a
+ Intro: class Eq a
+ Intro: class Eq1 (f :: * -> *)
+ Intro: class Eq2 (f :: * -> * -> *)
+ Intro: class Bits b => FiniteBits b
+ Intro: class Fractional a => Floating a
+ Intro: class Foldable (t :: * -> *)
+ Intro: class Num a => Fractional a
+ Intro: class Functor (f :: * -> *)
+ Intro: class Generic a
+ Intro: class Hashable a
+ Intro: class (Real a, Enum a) => Integral a
+ Intro: class IsList l where type Item l :: * where {
+ Intro: class IsString a
+ Intro: class Applicative m => Monad (m :: * -> *)
+ Intro: class Monad m => MonadError e (m :: * -> *) | m -> e
+ Intro: class Monad m => MonadFail (m :: * -> *)
+ Intro: class Monad m => MonadIO (m :: * -> *)
+ Intro: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ Intro: class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (m :: * -> *) | m -> r, m -> w, m -> s
+ Intro: class Monad m => MonadReader r (m :: * -> *) | m -> r
+ Intro: class Monad m => MonadState s (m :: * -> *) | m -> s
+ Intro: class MonadTrans (t :: (* -> *) -> * -> *)
+ Intro: class (Monoid w, Monad m) => MonadWriter w (m :: * -> *) | m -> w
+ Intro: class Monoid a
+ Intro: class NFData a
+ Intro: class Num a
+ Intro: class Eq a => Ord a
+ Intro: class Eq1 f => Ord1 (f :: * -> *)
+ Intro: class Eq2 f => Ord2 (f :: * -> * -> *)
+ Intro: class Read a
+ Intro: class Read1 (f :: * -> *)
+ Intro: class Read2 (f :: * -> * -> *)
+ Intro: class (Num a, Ord a) => Real a
+ Intro: class (RealFrac a, Floating a) => RealFloat a
+ Intro: class (Real a, Fractional a) => RealFrac a
+ Intro: class Semigroup a
+ Intro: class Show a
+ Intro: class Show1 (f :: * -> *)
+ Intro: class Show2 (f :: * -> * -> *)
+ Intro: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Intro: class Typeable k (a :: k)
+ Intro: clearBit :: Bits a => a -> Int -> a
+ Intro: compare :: Ord a => a -> a -> Ordering
+ Intro: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ Intro: complement :: Bits a => a -> a
+ Intro: complementBit :: Bits a => a -> Int -> a
+ Intro: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
+ Intro: concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
+ Intro: const :: a -> b -> a
+ Intro: convertString :: ConvertibleStrings a b => a -> b
+ Intro: cos :: Floating a => a -> a
+ Intro: cosh :: Floating a => a -> a
+ Intro: countLeadingZeros :: FiniteBits b => b -> Int
+ Intro: countTrailingZeros :: FiniteBits b => b -> Int
+ Intro: curry :: ((a, b) -> c) -> a -> b -> c
+ Intro: cycleDef :: [a] -> [a] -> [a]
+ Intro: cycleMay :: [a] -> Maybe [a]
+ Intro: data Bool :: *
+ Intro: data ByteString :: *
+ Intro: data Char :: *
+ Intro: data Constraint :: *
+ Intro: data DList a :: * -> *
+ Intro: data Double :: *
+ Intro: data Either a b :: * -> * -> *
+ Intro: data Float :: *
+ Intro: data HashMap k v :: * -> * -> *
+ Intro: data HashSet a :: * -> *
+ Intro: data IO a :: * -> *
+ Intro: data Int :: *
+ Intro: data Int16 :: *
+ Intro: data Int32 :: *
+ Intro: data Int64 :: *
+ Intro: data Int8 :: *
+ Intro: data IntMap a :: * -> *
+ Intro: data IntSet :: *
+ Intro: data Integer :: *
+ Intro: data Map k a :: * -> * -> *
+ Intro: data Maybe a :: * -> *
+ Intro: data Natural :: *
+ Intro: data NonEmpty a :: * -> *
+ Intro: data Ordering :: *
+ Intro: data Proxy k (t :: k) :: forall k. k -> *
+ Intro: data RWST r w s (m :: * -> *) a :: * -> * -> * -> (* -> *) -> * -> *
+ Intro: data Ratio a :: * -> *
+ Intro: data Seq a :: * -> *
+ Intro: data Set a :: * -> *
+ Intro: data Text :: *
+ Intro: data Void :: *
+ Intro: data Word :: *
+ Intro: data Word16 :: *
+ Intro: data Word32 :: *
+ Intro: data Word64 :: *
+ Intro: data Word8 :: *
+ Intro: data WriterT w (m :: * -> *) a :: * -> (* -> *) -> * -> *
+ Intro: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Intro: denominator :: Ratio a -> a
+ Intro: div :: Integral a => a -> a -> a
+ Intro: divMod :: Integral a => a -> a -> (a, a)
+ Intro: drop :: Int -> [a] -> [a]
+ Intro: dropEnd :: Int -> [a] -> [a]
+ Intro: dropWhile :: (a -> Bool) -> [a] -> [a]
+ Intro: dropWhileEnd :: (a -> Bool) -> [a] -> [a]
+ Intro: either :: (a -> c) -> (b -> c) -> Either a b -> c
+ Intro: eitherToMaybe :: Either a b -> Maybe b
+ Intro: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Intro: empty :: Alternative f => f a
+ Intro: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Intro: enumFrom :: Enum a => a -> [a]
+ Intro: enumFromThen :: Enum a => a -> a -> [a]
+ Intro: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Intro: enumFromTo :: Enum a => a -> a -> [a]
+ Intro: evalRWS :: Monoid w => RWS r w s a -> r -> s -> (a, w)
+ Intro: evalRWST :: (Monad m, Monoid w) => RWST r w s m a -> r -> s -> m (a, w)
+ Intro: evalState :: State s a -> s -> a
+ Intro: evalStateT :: Monad m => StateT s m a -> s -> m a
+ Intro: even :: Integral a => a -> Bool
+ Intro: execRWS :: Monoid w => RWS r w s a -> r -> s -> (s, w)
+ Intro: execRWST :: (Monad m, Monoid w) => RWST r w s m a -> r -> s -> m (s, w)
+ Intro: execState :: State s a -> s -> s
+ Intro: execStateT :: Monad m => StateT s m a -> s -> m s
+ Intro: execWriter :: Monoid w => Writer w a -> w
+ Intro: execWriterT :: (Monad m, Monoid w) => WriterT w m a -> m w
+ Intro: exp :: Floating a => a -> a
+ Intro: exponent :: RealFloat a => a -> Int
+ Intro: fail :: MonadFail m => String -> m a
+ Intro: filter :: (a -> Bool) -> [a] -> [a]
+ Intro: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
+ Intro: finiteBitSize :: FiniteBits b => b -> Int
+ Intro: first :: Bifunctor p => (a -> b) -> p a c -> p b c
+ Intro: fix :: (a -> a) -> a
+ Intro: flip :: (a -> b -> c) -> b -> a -> c
+ Intro: floatDigits :: RealFloat a => a -> Int
+ Intro: floatRadix :: RealFloat a => a -> Integer
+ Intro: floatRange :: RealFloat a => a -> (Int, Int)
+ Intro: floor :: (RealFrac a, Integral b) => a -> b
+ Intro: fold :: (Foldable t, Monoid m) => t m -> m
+ Intro: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ Intro: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ Intro: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ Intro: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Intro: foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Intro: foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
+ Intro: for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
+ Intro: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
+ Intro: fromEnum :: Enum a => a -> Int
+ Intro: fromInteger :: Num a => Integer -> a
+ Intro: fromIntegral :: (Integral a, Num b) => a -> b
+ Intro: fromLeft :: a -> Either a b -> a
+ Intro: fromList :: IsList l => [Item l] -> l
+ Intro: fromMaybe :: a -> Maybe a -> a
+ Intro: fromRational :: Fractional a => Rational -> a
+ Intro: fromRight :: b -> Either a b -> b
+ Intro: fromString :: IsString a => String -> a
+ Intro: fst :: (a, b) -> a
+ Intro: get :: MonadState s m => m s
+ Intro: gets :: MonadState s m => (s -> a) -> m a
+ Intro: group :: Eq a => [a] -> [[a]]
+ Intro: groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
+ Intro: groupOn :: Eq b => (a -> b) -> [a] -> [[a]]
+ Intro: guard :: Alternative f => Bool -> f ()
+ Intro: headDef :: a -> [a] -> a
+ Intro: headMay :: [a] -> Maybe a
+ Intro: id :: Category k cat => cat a a
+ Intro: ifM :: Monad m => m Bool -> m a -> m a -> m a
+ Intro: infix 4 `notElem`
+ Intro: infixl 0 `on`
+ Intro: infixl 1 &
+ Intro: infixl 4 <$!>
+ Intro: infixl 7 %
+ Intro: infixr 0 $!
+ Intro: infixr 1 >=>
+ Intro: infixr 2 ||
+ Intro: infixr 3 &&
+ Intro: initDef :: [a] -> [a] -> [a]
+ Intro: initMay :: [a] -> Maybe [a]
+ Intro: inits :: [a] -> [[a]]
+ Intro: intercalate :: [a] -> [[a]] -> [a]
+ Intro: intersperse :: a -> [a] -> [a]
+ Intro: isDenormalized :: RealFloat a => a -> Bool
+ Intro: isIEEE :: RealFloat a => a -> Bool
+ Intro: isInfinite :: RealFloat a => a -> Bool
+ Intro: isJust :: Maybe a -> Bool
+ Intro: isLeft :: Either a b -> Bool
+ Intro: isNaN :: RealFloat a => a -> Bool
+ Intro: isNegativeZero :: RealFloat a => a -> Bool
+ Intro: isNothing :: Maybe a -> Bool
+ Intro: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ Intro: isRight :: Either a b -> Bool
+ Intro: isSigned :: Bits a => a -> Bool
+ Intro: isSuffixOf :: Eq a => [a] -> [a] -> Bool
+ Intro: iterate :: (a -> a) -> a -> [a]
+ Intro: join :: Monad m => m (m a) -> m a
+ Intro: lastDef :: a -> [a] -> a
+ Intro: lastMay :: [a] -> Maybe a
+ Intro: lefts :: [Either a b] -> [a]
+ Intro: length :: Foldable t => forall a. t a -> Int
+ Intro: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ Intro: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ Intro: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ Intro: liftIO :: MonadIO m => IO a -> m a
+ Intro: listToMaybe :: [a] -> Maybe a
+ Intro: listen :: MonadWriter w m => m a -> m (a, w)
+ Intro: local :: MonadReader r m => (r -> r) -> m a -> m a
+ Intro: log :: Floating a => a -> a
+ Intro: logBase :: Floating a => a -> a -> a
+ Intro: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Intro: many :: Alternative f => f a -> f [a]
+ Intro: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ Intro: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ Intro: mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b
+ Intro: mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b
+ Intro: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+ Intro: mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
+ Intro: mapRWS :: (Monoid w, Monoid w') => ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b
+ Intro: mapRWST :: (Monad n, Monoid w, Monoid w') => (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
+ Intro: mapReader :: (a -> b) -> Reader r a -> Reader r b
+ Intro: mapReaderT :: (m a -> n b) -> ReaderT k1 r m a -> ReaderT k r n b
+ Intro: mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
+ Intro: mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
+ Intro: mapWriter :: (Monoid w, Monoid w') => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
+ Intro: mapWriterT :: (Monad n, Monoid w, Monoid w') => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
+ Intro: mappend :: Monoid a => a -> a -> a
+ Intro: max :: Ord a => a -> a -> a
+ Intro: maxBound :: Bounded a => a
+ Intro: maximumByDef :: a -> (a -> a -> Ordering) -> [a] -> a
+ Intro: maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
+ Intro: maximumDef :: Ord a => a -> [a] -> a
+ Intro: maximumMay :: Ord a => [a] -> Maybe a
+ Intro: maybe :: b -> (a -> b) -> Maybe a -> b
+ Intro: maybeToEither :: a -> Maybe b -> Either a b
+ Intro: maybeToList :: Maybe a -> [a]
+ Intro: mconcat :: Monoid a => [a] -> a
+ Intro: mempty :: Monoid a => a
+ Intro: min :: Ord a => a -> a -> a
+ Intro: minBound :: Bounded a => a
+ Intro: minimumByDef :: a -> (a -> a -> Ordering) -> [a] -> a
+ Intro: minimumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
+ Intro: minimumDef :: Ord a => a -> [a] -> a
+ Intro: minimumMay :: Ord a => [a] -> Maybe a
+ Intro: mod :: Integral a => a -> a -> a
+ Intro: modify :: MonadState s m => (s -> s) -> m ()
+ Intro: modify' :: MonadState s m => (s -> s) -> m ()
+ Intro: mplus :: MonadPlus m => m a -> m a -> m a
+ Intro: mzero :: MonadPlus m => m a
+ Intro: negate :: Num a => a -> a
+ Intro: newtype All :: *
+ Intro: newtype Alt k (f :: k -> *) (a :: k) :: forall k. (k -> *) -> k -> *
+ Intro: newtype Any :: *
+ Intro: newtype Const k a (b :: k) :: forall k. * -> k -> *
+ Intro: newtype Down a :: * -> *
+ Intro: newtype Dual a :: * -> *
+ Intro: newtype Endo a :: * -> *
+ Intro: newtype ExceptT e (m :: * -> *) a :: * -> (* -> *) -> * -> *
+ Intro: newtype First a :: * -> *
+ Intro: newtype Identity a :: * -> *
+ Intro: newtype Last a :: * -> *
+ Intro: newtype Max a :: * -> *
+ Intro: newtype MaybeT (m :: * -> *) a :: (* -> *) -> * -> *
+ Intro: newtype Min a :: * -> *
+ Intro: newtype Option a :: * -> *
+ Intro: newtype ReaderT k r (m :: k -> *) (a :: k) :: forall k. * -> (k -> *) -> k -> *
+ Intro: newtype StateT s (m :: * -> *) a :: * -> (* -> *) -> * -> *
+ Intro: newtype Tagged k (s :: k) b :: forall k. k -> * -> *
+ Intro: newtype ZipList a :: * -> *
+ Intro: not :: Bool -> Bool
+ Intro: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Intro: nubOrd :: Ord a => [a] -> [a]
+ Intro: nubOrdBy :: (a -> a -> Ordering) -> [a] -> [a]
+ Intro: nubOrdOn :: Ord b => (a -> b) -> [a] -> [a]
+ Intro: null :: Foldable t => forall a. t a -> Bool
+ Intro: numerator :: Ratio a -> a
+ Intro: odd :: Integral a => a -> Bool
+ Intro: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
+ Intro: optional :: Alternative f => f a -> f (Maybe a)
+ Intro: or :: Foldable t => t Bool -> Bool
+ Intro: orM :: Monad m => [m Bool] -> m Bool
+ Intro: otherwise :: Bool
+ Intro: partitionEithers :: [Either a b] -> ([a], [b])
+ Intro: pass :: MonadWriter w m => m (a, w -> w) -> m a
+ Intro: permutations :: [a] -> [[a]]
+ Intro: pi :: Floating a => a
+ Intro: popCount :: Bits a => a -> Int
+ Intro: product :: (Foldable t, Num a) => t a -> a
+ Intro: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Intro: pure :: Applicative f => a -> f a
+ Intro: put :: MonadState s m => s -> m ()
+ Intro: quot :: Integral a => a -> a -> a
+ Intro: quotRem :: Integral a => a -> a -> (a, a)
+ Intro: reader :: MonadReader r m => (r -> a) -> m a
+ Intro: realToFrac :: (Real a, Fractional b) => a -> b
+ Intro: recip :: Fractional a => a -> a
+ Intro: rem :: Integral a => a -> a -> a
+ Intro: repeat :: a -> [a]
+ Intro: replicate :: Int -> a -> [a]
+ Intro: replicateM :: Applicative m => Int -> m a -> m [a]
+ Intro: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Intro: reverse :: [a] -> [a]
+ Intro: rights :: [Either a b] -> [b]
+ Intro: rotate :: Bits a => a -> Int -> a
+ Intro: rotateL :: Bits a => a -> Int -> a
+ Intro: rotateR :: Bits a => a -> Int -> a
+ Intro: round :: (RealFrac a, Integral b) => a -> b
+ Intro: runExcept :: Except e a -> Either e a
+ Intro: runExceptT :: ExceptT e m a -> m (Either e a)
+ Intro: runRWS :: Monoid w => RWS r w s a -> r -> s -> (a, s, w)
+ Intro: runRWST :: Monoid w => RWST r w s m a -> r -> s -> m (a, s, w)
+ Intro: runReader :: Reader r a -> r -> a
+ Intro: runState :: State s a -> s -> (a, s)
+ Intro: runWriter :: Monoid w => Writer w a -> (a, w)
+ Intro: runWriterT :: Monoid w => WriterT w m a -> m (a, w)
+ Intro: scaleFloat :: RealFloat a => Int -> a -> a
+ Intro: scanl :: (b -> a -> b) -> b -> [a] -> [b]
+ Intro: scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
+ Intro: scanr :: (a -> b -> b) -> b -> [a] -> [b]
+ Intro: scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
+ Intro: sconcat :: Semigroup a => NonEmpty a -> a
+ Intro: second :: Bifunctor p => (b -> c) -> p a b -> p a c
+ Intro: seq :: a -> b -> b
+ Intro: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
+ Intro: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
+ Intro: setBit :: Bits a => a -> Int -> a
+ Intro: shift :: Bits a => a -> Int -> a
+ Intro: significand :: RealFloat a => a -> a
+ Intro: signum :: Num a => a -> a
+ Intro: sin :: Floating a => a -> a
+ Intro: sinh :: Floating a => a -> a
+ Intro: snd :: (a, b) -> b
+ Intro: some1 :: Alternative f => f a -> f (NonEmpty a)
+ Intro: sort :: Ord a => [a] -> [a]
+ Intro: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
+ Intro: sortOn :: Ord b => (a -> b) -> [a] -> [a]
+ Intro: span :: (a -> Bool) -> [a] -> ([a], [a])
+ Intro: splitAt :: Int -> [a] -> ([a], [a])
+ Intro: sqrt :: Floating a => a -> a
+ Intro: state :: MonadState s m => (s -> (a, s)) -> m a
+ Intro: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ Intro: subsequences :: [a] -> [[a]]
+ Intro: sum :: (Foldable t, Num a) => t a -> a
+ Intro: swap :: (a, b) -> (b, a)
+ Intro: tailDef :: [a] -> [a] -> [a]
+ Intro: tailMay :: [a] -> Maybe [a]
+ Intro: tails :: [a] -> [[a]]
+ Intro: take :: Int -> [a] -> [a]
+ Intro: takeEnd :: Int -> [a] -> [a]
+ Intro: takeWhile :: (a -> Bool) -> [a] -> [a]
+ Intro: tan :: Floating a => a -> a
+ Intro: tanh :: Floating a => a -> a
+ Intro: tell :: MonadWriter w m => w -> m ()
+ Intro: testBit :: Bits a => a -> Int -> Bool
+ Intro: throwError :: MonadError e m => e -> m a
+ Intro: toEnumDef :: (Enum a, Bounded a) => a -> Int -> a
+ Intro: toEnumMay :: (Enum a, Bounded a) => Int -> Maybe a
+ Intro: toInteger :: Integral a => a -> Integer
+ Intro: toList :: Foldable t => t a -> [a]
+ Intro: toRational :: Real a => a -> Rational
+ Intro: trace :: Text -> a -> a
+ Intro: traceIO :: Text -> IO ()
+ Intro: traceM :: Monad m => Text -> m ()
+ Intro: traceShow :: Show a => a -> b -> b
+ Intro: traceShowM :: (Show a, Monad m) => a -> m ()
+ Intro: traceStack :: Text -> a -> a
+ Intro: traceStackM :: Monad m => Text -> m ()
+ Intro: transpose :: [[a]] -> [[a]]
+ Intro: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ Intro: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
+ Intro: truncate :: (RealFrac a, Integral b) => a -> b
+ Intro: type Except e = ExceptT e Identity
+ Intro: type FilePath = String
+ Intro: type LHashMap = HashMap
+ Intro: type LMap = Map
+ Intro: type RWS r w s = RWST r w s Identity
+ Intro: type Rational = Ratio Integer
+ Intro: type Reader r = ReaderT * r Identity
+ Intro: type State s = StateT s Identity
+ Intro: type String = [Char]
+ Intro: type Type = *
+ Intro: type Writer w = WriterT w Identity
+ Intro: type family Item l :: *;
+ Intro: unTagged :: Tagged k s b -> b
+ Intro: uncurry :: (a -> b -> c) -> (a, b) -> c
+ Intro: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+ Intro: unless :: Applicative f => Bool -> f () -> f ()
+ Intro: unlessM :: Monad m => m Bool -> m () -> m ()
+ Intro: until :: (a -> Bool) -> (a -> a) -> a -> a
+ Intro: unzip :: [(a, b)] -> ([a], [b])
+ Intro: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
+ Intro: void :: Functor f => f a -> f ()
+ Intro: when :: Applicative f => Bool -> f () -> f ()
+ Intro: whenM :: Monad m => m Bool -> m () -> m ()
+ Intro: withExcept :: (e -> e') -> Except e a -> Except e' a
+ Intro: withExceptT :: Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
+ Intro: withReader :: (r' -> r) -> Reader r a -> Reader r' a
+ Intro: withReaderT :: (r' -> r) -> ReaderT k r m a -> ReaderT k r' m a
+ Intro: withState :: (s -> s) -> State s a -> State s a
+ Intro: withStateT :: (s -> s) -> StateT s m a -> StateT s m a
+ Intro: writer :: MonadWriter w m => (a, w) -> m a
+ Intro: xor :: Bits a => a -> a -> a
+ Intro: zeroBits :: Bits a => a
+ Intro: zip :: [a] -> [b] -> [(a, b)]
+ Intro: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
+ Intro: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+ Intro: zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+ Intro: }
- Intro: infixr 8 .:
+ Intro: infixr 8 ^^
Files
- intro.cabal +5/−3
- src/Intro.hs +694/−675
- src/Intro/Trustworthy.hs +29/−25
intro.cabal view
@@ -3,9 +3,9 @@ -- see: https://github.com/sol/hpack name: intro-version: 0.0.1.0-synopsis: Total, Texty, Transformer-Prelude-description: Total, Text, Transformer-Prelude+version: 0.0.2.0+synopsis: Total Prelude with Text and Monad transformers+description: Modern Prelude which provides safe alternatives for most of the partial functions. Text is preferred over String. Container types and Monad transformers are provided. Most important - this Prelude avoids fanciness. This means it just reexports from base and commonly used libraries and doesn\'t invent its own stuff. Everything is in one file. category: Prelude homepage: https://github.com/minad/intro#readme bug-reports: https://github.com/minad/intro/issues@@ -46,5 +46,7 @@ , writer-cps-mtl >= 0.1.1 && < 0.2 exposed-modules: Intro+ other-modules: Intro.Trustworthy+ Paths_intro default-language: Haskell2010
src/Intro.hs view
@@ -1,681 +1,700 @@ {-# LANGUAGE Safe #-} {-# LANGUAGE FlexibleContexts #-} module Intro (- module X,- LText,- LByteString,- (.:),- (<>^),- skip,- panic,- map,- print,- getContents,- getLine,- getChar,- putChar,- putStr,- putStrLn,- show,- showS,- readMaybe,- undefined,- readFile,- writeFile,- appendFile,- readFileUtf8,- writeFileUtf8,- appendFileUtf8,-) where--import Data.Either.Extra as X (- fromLeft,- fromRight,- eitherToMaybe,- maybeToEither,- )--import Control.Monad.Extra as X (- whenM,- unlessM,- ifM,- allM,- anyM,- andM,- orM,- concatMapM,- (&&^),- (||^),- )--import Data.List.Extra as X (- nubOrd,- nubOrdOn,- nubOrdBy,- groupOn,- dropEnd,- takeEnd,- )--import Data.Text as X (- Text,--- lines,--- words,--- unlines,--- unwords,- )--import Data.ByteString as X (- ByteString- )--import Data.Map.Strict as X (- Map,- )--import Data.IntMap.Strict as X (- IntMap,- )--import Data.Set as X (- Set,- )--import Data.IntSet as X (- IntSet,- )--import Data.Sequence as X (- Seq,- )--import Data.HashMap.Strict as X (- HashMap,- )--import Data.HashSet as X (- HashSet,- )--import Data.Hashable as X (- Hashable,- )--import Data.Int as X (- Int,- Int8,- Int16,- Int32,- Int64,- )--import Data.Bits as X (- Bits((.&.), (.|.), xor, complement, shift, rotate, zeroBits,- bit, setBit, clearBit, complementBit, testBit,- -- bitSize, bitSizeMaybe- isSigned,- -- unsafeShiftL- -- unsafeShiftR- -- shiftR, shiftL,- rotateL, rotateR, popCount),- FiniteBits(finiteBitSize, countLeadingZeros, countTrailingZeros)- )--import Data.Tuple as X (- fst,- snd,- curry,- uncurry,- swap- )--import Data.Word as X (- Word,- Word8,- Word16,- Word32,- Word64,- )--import Data.Function as X (--- id,- const,--- (.),- flip,- ($),- (&),- fix,- on,- )--import Data.Either as X (- Either(Left, Right),- either,- lefts,- rights,- isLeft,- isRight,- partitionEithers,- )--import Data.Maybe as X (- Maybe(Nothing, Just),- maybe,- isJust,- isNothing,- fromMaybe,- listToMaybe,- maybeToList,- catMaybes,- mapMaybe,- )--import Data.Bool as X (- Bool(False, True),- (&&),- (||),- not,- otherwise,- bool,- )--import Data.Functor as X (- Functor((<$)),- --fmap,- ($>),- (<$>),- void- )--import Data.Functor.Classes as X (- Eq1, Eq2,- Ord1, Ord2,- Show1, Show2,- Read1, Read2- )--import Data.Bifunctor as X (- Bifunctor(bimap, first, second),- )--import Data.Bifoldable as X (- Bifoldable(bifoldr, bifoldl, bifoldMap),- bitraverse_,- bisequenceA_,- bifor_,- )--import Data.Bitraversable as X (- Bitraversable(bitraverse),- bifor,- bisequenceA,- )--import Data.Void as X (- Void,- absurd- )--import Data.Kind as X (- Type,- Constraint,- )--import Control.Category as X (- id,- (.),- (<<<),- (>>>)- )--import Data.Semigroup as X (- Semigroup((<>), sconcat, stimes),- First(First, getFirst),- Last(Last, getLast),- Min(Min, getMin),- Max(Max, getMax),- Option(Option, getOption),- )--import Data.Monoid as X (- Monoid(mempty, mappend, mconcat),- Dual(Dual, getDual),- Endo(Endo, appEndo),- All(All, getAll),- Any(Any, getAny),- -- Hide because of name clash with sum functors- --Sum(Sum, getSum),- --Product(Product, getProduct),- -- Provide semigroup instances instead- --First(First, getFirst),- --Last(Last, getLast),- Alt(Alt, getAlt),- )--import Data.Eq as X (- Eq((==), (/=)),- )--import Data.Ord as X (- Ord(compare, (<), (>), (<=), (>=), max, min),- Ordering(LT,GT,EQ),- Down(Down),- comparing- )--import Text.Show as X (- Show- )--import Text.Read as X (- Read- )--import Control.Applicative as X (- Applicative(pure, (<*>), (*>), (<*)),- Alternative((<|>), empty, many {-, some -}),- Const(Const, getConst),- ZipList(ZipList, getZipList),- (<**>),- optional,- liftA2,- liftA3,- )--import Control.Monad as X (- Monad((>>=)),- (=<<),- (<=<),- (>=>),- MonadPlus(mzero, mplus),- join,- guard,- when,- unless,- replicateM,- replicateM_,- (<$!>)- )--import Control.Monad.Fail as X (- MonadFail(fail),- )--import Data.Foldable as X (- Foldable(elem, fold, foldMap,- foldr, foldr',- -- foldl, -- hide the bad one- foldl',- product, sum, toList),- null,- length,- foldrM,- foldlM,- traverse_,- for_,- asum,- concatMap,- all,- any,- or,- and,- find,- notElem,- sequenceA_,- )--import Safe as X (- headMay,- headDef,- tailMay,- tailDef,- initMay,- initDef,- lastMay,- lastDef,- toEnumMay,- toEnumDef,- cycleMay,- cycleDef- )--import Safe.Foldable as X (- maximumByMay,- maximumByDef,- minimumByMay,- minimumByDef,- maximumMay,- maximumDef,- minimumMay,- minimumDef,- )--import Data.Ratio as X (- Ratio,- Rational,- (%),- numerator,- denominator,- approxRational- )--import Numeric.Natural as X (- Natural- )--import Prelude as X (- ($!),- (^), -- partial functions!- (^^),- seq,- Char,- String,- Float,- Double,- Integer,- FilePath,- realToFrac,- even,- odd,- asTypeOf,- until,- fromIntegral,- Num((+), (-), (*), negate, abs, signum, fromInteger),- Real(toRational),- Integral(quot, rem, div, mod, quotRem, divMod, toInteger), -- partial functions!- Fractional((/), recip, fromRational), -- partial functions- Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,- asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),- RealFrac(properFraction, truncate, round, ceiling, floor), -- partial functions- RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,- encodeFloat, exponent, significand, scaleFloat, isNaN,- isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),- Enum(-- toEnum, succ, pred, -- partial- fromEnum, enumFrom, enumFromThen,- enumFromTo, enumFromThenTo),- Bounded(minBound, maxBound),- )--import System.IO as X (- IO- )--import Data.List as X (- splitAt,- break,- span,- intercalate,- isPrefixOf,- isSuffixOf,- drop,- filter,- reverse,- replicate,- take,- sortBy,- sortOn,- sort,- intersperse,- transpose,- subsequences,- permutations,- scanl,- scanr,- iterate,- repeat,- -- cycle, -- partial- unfoldr,- takeWhile,- dropWhile,- dropWhileEnd,- group,- groupBy,- inits,- tails,- zip,- zip3,- zipWith,- zipWith3,- lookup,- unzip,- unzip3- )--import Data.List.NonEmpty as X (- NonEmpty((:|)),- (<|),- some1,- scanl1,- scanr1- )--import Data.Traversable as X (- Traversable(traverse, sequenceA),- for,- mapAccumL,- mapAccumR,- )--import Data.Functor.Identity as X (- Identity(Identity, runIdentity),- )--import Control.Monad.Reader as X (- MonadReader(ask, local, reader),- --asks,- Reader,- runReader,- mapReader,- withReader,- ReaderT(ReaderT, runReaderT),- mapReaderT,- withReaderT- )--import Control.Monad.Trans.Maybe as X (- MaybeT(MaybeT, runMaybeT),- mapMaybeT,- )--import Control.Monad.Except as X (- MonadError(throwError, catchError),- ExceptT(ExceptT),- runExceptT,- mapExceptT,- withExceptT,- Except,- runExcept,- mapExcept,- withExcept,- )--import Control.Monad.State.Strict as X (- MonadState(get, put, state),- State,- --gets,- modify,- modify',- runState,- evalState,- execState,- mapState,- withState,- StateT(StateT, runStateT),- evalStateT,- execStateT,- mapStateT,- withStateT,- )--import Control.Monad.RWS.CPS as X (- MonadRWS,- RWS,- runRWS,- evalRWS,- execRWS,- mapRWS,- RWST,- runRWST,- evalRWST,- execRWST,- mapRWST,- )--import Control.Monad.Writer.CPS as X (- MonadWriter(writer, tell, listen, pass),- Writer,- runWriter,- execWriter,- mapWriter,- WriterT,- runWriterT,- execWriterT,- mapWriterT,- )--import Control.Monad.Trans as X (- MonadTrans(lift),- MonadIO(liftIO),- )--import GHC.Generics as X (- Generic- )--import Data.Typeable as X (- Typeable- )---- import Data.Data as X (--- Data--- )--import Data.String as X (- IsString(fromString)- )--import Data.Proxy as X (- Proxy(Proxy)- )--import Data.Tagged as X (- Tagged(Tagged, unTagged)- )--import Data.String.Conversions as X (- ConvertibleStrings(convertString)- )--import Control.DeepSeq as X (- NFData- )--import Data.Binary as X (- Binary- )--import Intro.Trustworthy as X--import qualified Prelude-import qualified GHC.Stack.Types-import qualified Data.Functor-import qualified Data.Text.IO-import qualified Data.ByteString-import qualified Data.ByteString.Lazy-import qualified Data.Text.Lazy-import qualified Text.Read-import qualified Text.Show-import qualified System.IO--type LText = Data.Text.Lazy.Text-type LByteString = Data.ByteString.Lazy.ByteString--map :: Functor f => (a -> b) -> f a -> f b-map = Data.Functor.fmap-{-# INLINE map #-}--show :: (Show a, ConvertibleStrings String b) => a -> b-show = convertString . showS-{-# INLINE show #-}--showS :: Show a => a -> String-showS = Text.Show.show-{-# INLINE showS #-}--readMaybe :: (Read b, ConvertibleStrings a String) => a -> Maybe b-readMaybe = Text.Read.readMaybe . convertString-{-# INLINE readMaybe #-}--print :: (MonadIO m, Show a) => a -> m ()-print = liftIO . System.IO.print-{-# INLINE print #-}--getContents :: MonadIO m => m Text-getContents = liftIO Data.Text.IO.getContents-{-# INLINE getContents #-}--getLine :: MonadIO m => m Text-getLine = liftIO Data.Text.IO.getLine-{-# INLINE getLine #-}--getChar :: MonadIO m => m Char-getChar = liftIO System.IO.getChar-{-# INLINE getChar #-}--putStr, putStrLn :: MonadIO m => Text -> m ()-putStr = liftIO . Data.Text.IO.putStr-putStrLn = liftIO . Data.Text.IO.putStrLn-{-# INLINE putStr #-}-{-# INLINE putStrLn #-}--putChar :: MonadIO m => Char -> m ()-putChar = liftIO . System.IO.putChar-{-# INLINE putChar #-}--readFile :: MonadIO m => FilePath -> m ByteString-readFile = liftIO . Data.ByteString.readFile-{-# INLINE readFile #-}--writeFile :: MonadIO m => FilePath -> ByteString -> m ()-writeFile = liftIO .: Data.ByteString.writeFile-{-# INLINE writeFile #-}--appendFile :: MonadIO m => FilePath -> ByteString -> m ()-appendFile = liftIO .: Data.ByteString.appendFile-{-# INLINE appendFile #-}--readFileUtf8 :: MonadIO m => FilePath -> m Text-readFileUtf8 = map convertString . readFile-{-# INLINE readFileUtf8 #-}--writeFileUtf8 :: MonadIO m => FilePath -> Text -> m ()-writeFileUtf8 file = writeFile file . convertString-{-# INLINE writeFileUtf8 #-}--appendFileUtf8 :: MonadIO m => FilePath -> Text -> m ()-appendFileUtf8 file = appendFile file . convertString-{-# INLINE appendFileUtf8 #-}--{-# WARNING undefined "'undefined' remains in code" #-}-undefined :: GHC.Stack.Types.HasCallStack => a-undefined = Prelude.undefined--infixr 6 <>^-(<>^) :: (Applicative f, Semigroup a) => f a -> f a -> f a-(<>^) = liftA2 (<>)-{-# INLINE (<>^) #-}--infixr 8 .:-(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d-(.:) = (.) . (.)-{-# INLINE (.:) #-}--skip :: Applicative m => m ()-skip = pure ()-{-# INLINE skip #-}--panic :: GHC.Stack.Types.HasCallStack => a-panic = Prelude.error $+ -- * Basic functions+ -- Data.Function.id+ -- , (Data.Function..)+ Data.Function.const+ , Data.Function.flip+ , (Data.Function.$)+ , (Prelude.$!)+ , (Data.Function.&)+ , Data.Function.fix+ , Data.Function.on+ , (.:)+ , Prelude.until+ , Prelude.asTypeOf+ , Prelude.seq++ -- * Basic algebraic types++ -- ** Void+ , Data.Void.Void++ -- ** Bool+ , Data.Bool.Bool(False, True)+ , (Data.Bool.&&)+ , (Data.Bool.||)+ , Data.Bool.bool+ , Data.Bool.not+ , Data.Bool.otherwise++ -- ** Maybe+ , Data.Maybe.Maybe(Nothing, Just)+ , Data.Maybe.catMaybes+ , Data.Maybe.fromMaybe+ , Data.Maybe.isJust+ , Data.Maybe.isNothing+ , Data.Maybe.listToMaybe+ , Data.Maybe.mapMaybe+ , Data.Maybe.maybe+ , Data.Maybe.maybeToList++ -- ** List+ , Intro.Trustworthy.IsList(+ Item+ , fromList+ -- , toList -- provided by Foldable+ )+ , Data.List.break+ , 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.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.splitAt+ , 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+ -- , Data.List.cycle -- partial+ , Safe.headDef+ , Safe.headMay+ , Safe.initDef+ , Safe.initMay+ , Safe.lastDef+ , Safe.lastMay+ , Safe.tailDef+ , Safe.tailMay+ , Safe.cycleMay+ , Safe.cycleDef++ -- ** NonEmpty+ , Data.List.NonEmpty.NonEmpty((:|))+ -- (<|), -- in lens+ , Data.List.NonEmpty.scanl1+ , Data.List.NonEmpty.scanr1++ -- ** Tuple+ , Data.Tuple.fst+ , Data.Tuple.snd+ , Data.Tuple.curry+ , Data.Tuple.uncurry+ , Data.Tuple.swap++ -- ** Either+ , 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++ -- * Char, String and Text+ , Prelude.Char+ , Prelude.String+ , Data.Text.Text+ , LText+-- Data.Text.lines, -- Use qualified import instead+-- Data.Text.words,+-- Data.Text.unlines,+-- Data.Text.unwords,+ , Data.ByteString.ByteString+ , LByteString+ , Data.String.IsString(fromString)+ , Data.String.Conversions.ConvertibleStrings(convertString)++ -- * Container types++ -- ** Ordered Map and Set+ , Data.Map.Strict.Map+ , LMap+ , Data.Set.Set+ , Data.IntMap.Strict.IntMap+ , Data.IntSet.IntSet++ -- ** Hashed Map and Set+ , Data.HashMap.Strict.HashMap+ , LHashMap+ , Data.HashSet.HashSet+ , Data.Hashable.Hashable++ -- ** Seq+ , Data.Sequence.Seq++ -- ** DList+ , Intro.Trustworthy.DList++ -- * Numeric types++ -- ** Integer types+ , 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++ -- ** Floating point+ , Prelude.Float+ , Prelude.Double++ -- ** Rational+ , Data.Ratio.Ratio+ , Data.Ratio.Rational+ , (Data.Ratio.%)+ , Data.Ratio.numerator+ , Data.Ratio.denominator+ , Data.Ratio.approxRational++ -- * Numeric type classes++ -- ** Num+ , Prelude.Num((+), (-), (*), negate, abs, signum, fromInteger)+ , (Prelude.^) -- partial functions!++ -- ** Real+ , Prelude.Real(toRational)+ , Prelude.realToFrac++ -- ** Integral+ , Prelude.Integral(quot, rem, div, mod, quotRem, divMod, toInteger) -- partial functions!+ , Prelude.fromIntegral+ , Prelude.even+ , Prelude.odd++ -- ** Fractional+ , Prelude.Fractional((/), recip, fromRational) -- partial functions+ , (Prelude.^^)++ -- ** Floating+ , Prelude.Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,+ asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh)+ -- ** RealFrac+ , Prelude.RealFrac(properFraction, truncate, round, ceiling, floor) -- partial functions++ -- ** RealFloat+ , Prelude.RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,+ encodeFloat, exponent, significand, scaleFloat, isNaN,+ isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2)++ -- ** Bits+ , Data.Bits.Bits((.&.), (.|.), xor, complement, shift, rotate, zeroBits,+ bit, setBit, clearBit, complementBit, testBit,+ -- bitSize, bitSizeMaybe+ isSigned,+ -- unsafeShiftL+ -- unsafeShiftR+ -- shiftR, shiftL,+ rotateL, rotateR, popCount)+ , Data.Bits.FiniteBits(finiteBitSize, countLeadingZeros, countTrailingZeros)++ -- * Read and Show++ -- ** Show+ , Text.Show.Show+ , Data.Functor.Classes.Show1+ , Data.Functor.Classes.Show2+ , show+ , showS++ -- ** Read+ , Text.Read.Read+ , Data.Functor.Classes.Read1+ , Data.Functor.Classes.Read2+ , readMaybe++ -- * Eq, Ord, etc.++ -- ** Eq+ , Data.Eq.Eq((==), (/=))+ , Data.Functor.Classes.Eq1+ , Data.Functor.Classes.Eq2++ -- ** Ord+ , Data.Ord.Ord(compare, (<), (>), (<=), (>=), max, min)+ , Data.Functor.Classes.Ord1+ , Data.Functor.Classes.Ord2+ , Data.Ord.Ordering(LT,GT,EQ)+ , Data.Ord.Down(Down)+ , Data.Ord.comparing++ -- ** Enum+ , Prelude.Enum(-- toEnum, succ, pred, -- partial+ fromEnum, enumFrom, enumFromThen,+ enumFromTo, enumFromThenTo)+ , Safe.toEnumMay+ , Safe.toEnumDef++ -- ** Bounded+ , Prelude.Bounded(minBound, maxBound)++ -- * Algebraic type classes++ -- ** Category+ , Control.Category.Category(id, (.))+ , (Control.Category.<<<)+ , (Control.Category.>>>)++ -- ** Semigroup+ , 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)++ -- ** Monoid+ , 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)+ -- Hide because of name clash with sum functors+ --, Data.Monoid.Sum(Sum, getSum)+ --, Data.Monoid.Product(Product, getProduct)+ -- Provide semigroup instances instead+ --, Data.Monoid.First(First, getFirst)+ --, Data.Monoid.Last(Last, getLast)+ , Data.Monoid.Alt(Alt, getAlt)++ -- ** Functor+ , Data.Functor.Functor(+ (<$)+ --, fmap -- hide fmap, use map instead+ )+ , (Data.Functor.$>)+ , (Data.Functor.<$>)+ , map+ , Data.Functor.void+ , Data.Functor.Const.Const(Const, getConst)+ , Data.Functor.Identity.Identity(Identity, runIdentity)++ -- ** Applicative+ , Control.Applicative.Applicative(pure, (<*>), (*>), (<*))+ , Control.Applicative.ZipList(ZipList, getZipList)+ , (Control.Applicative.<**>)+ , Control.Applicative.liftA2+ , Control.Applicative.liftA3+ , skip+ , (<>^)++ -- ** Alternative+ , Control.Applicative.Alternative((<|>), empty, many {-, some -})+ , Control.Applicative.optional+ , Data.List.NonEmpty.some1++ -- ** Monad+ , Control.Monad.Monad((>>=))+ , Control.Monad.Fail.MonadFail(fail)+ , (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.||^)++ -- ** Foldable+ , Data.Foldable.Foldable(elem, fold, foldMap,+ foldr, foldr',+ -- foldl, -- hide the bad one+ 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.maximumByMay+ , Safe.maximumByDef+ , Safe.minimumByMay+ , Safe.minimumByDef+ , Safe.maximumMay+ , Safe.maximumDef+ , Safe.minimumMay+ , Safe.minimumDef++ -- ** Traversable+ , Data.Traversable.Traversable(traverse, sequenceA)+ , Data.Traversable.for+ , Data.Traversable.mapAccumL+ , Data.Traversable.mapAccumR++ -- ** Bifunctor+ , Data.Bifunctor.Bifunctor(bimap, first, second)++ -- ** Bifoldable+ , Data.Bifoldable.Bifoldable(bifoldr, bifoldl, bifoldMap)+ , Data.Bifoldable.bitraverse_+ , Data.Bifoldable.bisequenceA_+ , Data.Bifoldable.bifor_++ -- ** Bitraversable+ , Data.Bitraversable.Bitraversable(bitraverse)+ , Data.Bitraversable.bifor+ , Data.Bitraversable.bisequenceA++ -- * Monad transformer+ , Control.Monad.Trans.MonadTrans(lift)++ -- ** MaybeT+ , Control.Monad.Trans.Maybe.MaybeT(MaybeT, runMaybeT)+ , Control.Monad.Trans.Maybe.mapMaybeT++ -- ** MonadError and ExceptT+ , 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++ -- ** MonadReader and ReaderT+ , 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++ -- ** MonadWriter and WriterT+ , 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.runWriterT+ , Control.Monad.Writer.CPS.execWriterT+ , Control.Monad.Writer.CPS.mapWriterT++ -- ** MonadState and StateT+ , 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++ -- ** MonadRWS and RWST+ , Control.Monad.RWS.CPS.MonadRWS+ , 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.runRWST+ , Control.Monad.RWS.CPS.evalRWST+ , Control.Monad.RWS.CPS.execRWST+ , Control.Monad.RWS.CPS.mapRWST++ -- * Generic type classes+ , GHC.Generics.Generic+ , Data.Typeable.Typeable+ , Control.DeepSeq.NFData+ , Data.Binary.Binary++ -- * Type level stuff+ , Data.Kind.Type+ , Data.Kind.Constraint+ , Data.Proxy.Proxy(Proxy)+ , Data.Tagged.Tagged(Tagged)+ , Data.Tagged.unTagged++ -- * File and Console IO+ , Prelude.FilePath+ , System.IO.IO+ , Control.Monad.Trans.MonadIO(liftIO)+ , print+ , getContents+ , getLine+ , getChar+ , putChar+ , putStr+ , putStrLn+ , readFile+ , writeFile+ , appendFile+ , readFileUtf8+ , writeFileUtf8+ , appendFileUtf8++ -- * Error and Debugging+ , panic+ , undefined+ , Intro.Trustworthy.trace+ , Intro.Trustworthy.traceIO+ , Intro.Trustworthy.traceM+ , Intro.Trustworthy.traceShow+ , Intro.Trustworthy.traceShowM+ , Intro.Trustworthy.traceStack+ , Intro.Trustworthy.traceStackM+) where++import Control.Category ((.))+import Control.Monad.Trans (MonadIO(liftIO))+import Data.Semigroup ((<>))+import Data.String.Conversions (ConvertibleStrings(convertString))+import Data.Text (Text)+import Prelude (String, Char, FilePath)+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.Fail+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.Const+import qualified Data.Functor.Identity+import qualified Data.HashMap.Lazy+import qualified Data.HashMap.Strict+import qualified Data.HashSet+import qualified Data.Hashable+import qualified Data.Int+import qualified Data.IntMap.Strict+import qualified Data.IntSet+import qualified Data.Kind+import qualified Data.List+import qualified Data.List.Extra+import qualified Data.List.NonEmpty+import qualified Data.Map.Lazy+import qualified Data.Map.Strict+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.String+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 GHC.Stack.Types+import qualified Intro.Trustworthy+import qualified Numeric.Natural+import qualified Prelude+import qualified Safe+import qualified System.IO+import qualified Text.Read+import qualified Text.Show+import qualified Data.Functor.Classes++-- | Alias for lazy 'Data.Text.Lazy.Text'+type LText = Data.Text.Lazy.Text++-- | Alias for lazy 'Data.ByteString.Lazy.ByteString'+type LByteString = Data.ByteString.Lazy.ByteString++-- | Alias for lazy 'Data.Map.Lazy.Map'+type LMap = Data.Map.Lazy.Map++-- | Alias for lazy 'Data.HashMap.Lazy.HashMap'+type LHashMap = Data.HashMap.Lazy.HashMap++-- | Map over a 'Data.Functor.Functor' type+map :: Data.Functor.Functor f => (a -> b) -> f a -> f b+map = Data.Functor.fmap+{-# INLINE map #-}++show :: (Text.Show.Show a, ConvertibleStrings String b) => a -> b+show = convertString . showS+{-# INLINE show #-}++showS :: Text.Show.Show a => a -> String+showS = Text.Show.show+{-# INLINE showS #-}++readMaybe :: (Text.Read.Read b, ConvertibleStrings a String) => a -> Data.Maybe.Maybe b+readMaybe = Text.Read.readMaybe . convertString+{-# INLINE readMaybe #-}++print :: (MonadIO m, Text.Show.Show a) => a -> m ()+print = liftIO . System.IO.print+{-# INLINE print #-}++getContents :: MonadIO m => m Text+getContents = liftIO Data.Text.IO.getContents+{-# INLINE getContents #-}++getLine :: MonadIO m => m Text+getLine = liftIO Data.Text.IO.getLine+{-# INLINE getLine #-}++getChar :: MonadIO m => m Char+getChar = liftIO System.IO.getChar+{-# INLINE getChar #-}++putStr, putStrLn :: MonadIO m => Text -> m ()+putStr = liftIO . Data.Text.IO.putStr+putStrLn = liftIO . Data.Text.IO.putStrLn+{-# INLINE putStr #-}+{-# INLINE putStrLn #-}++putChar :: MonadIO m => Char -> m ()+putChar = liftIO . System.IO.putChar+{-# INLINE putChar #-}++readFile :: MonadIO m => FilePath -> m Data.ByteString.ByteString+readFile = liftIO . Data.ByteString.readFile+{-# INLINE readFile #-}++writeFile :: MonadIO m => FilePath -> Data.ByteString.ByteString -> m ()+writeFile = liftIO .: Data.ByteString.writeFile+{-# INLINE writeFile #-}++appendFile :: MonadIO m => FilePath -> Data.ByteString.ByteString -> m ()+appendFile = liftIO .: Data.ByteString.appendFile+{-# INLINE appendFile #-}++readFileUtf8 :: MonadIO m => FilePath -> m Text+readFileUtf8 = map convertString . readFile+{-# INLINE readFileUtf8 #-}++writeFileUtf8 :: MonadIO m => FilePath -> Text -> m ()+writeFileUtf8 file = writeFile file . convertString+{-# INLINE writeFileUtf8 #-}++appendFileUtf8 :: MonadIO m => FilePath -> Text -> m ()+appendFileUtf8 file = appendFile file . convertString+{-# INLINE appendFileUtf8 #-}++-- | Throw an undefined error. Use only for debugging.+undefined :: GHC.Stack.Types.HasCallStack => a+undefined = Prelude.undefined+{-# WARNING undefined "'undefined' remains in code" #-}++-- | '(<>)' lifted to 'Control.Applicative.Applicative'+(<>^) :: (Control.Applicative.Applicative f, Data.Semigroup.Semigroup a) => f a -> f a -> f a+(<>^) = Control.Applicative.liftA2 (Data.Semigroup.<>)+infixr 6 <>^+{-# INLINE (<>^) #-}++-- | Compose functions with one argument with function with two arguments+(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d+(.:) = (.) . (.)+infixr 8 .:+{-# INLINE (.:) #-}++-- | Shortcut for 'pure ()'+skip :: Control.Applicative.Applicative m => m ()+skip = Control.Applicative.pure ()+{-# INLINE skip #-}++-- | Throw an unhandled error. Use this function instead of 'Prelude.error'+panic :: GHC.Stack.Types.HasCallStack => a+panic = Prelude.error Data.Function.$ "Panic!\n" <> "Please submit a bug report including the stacktrace\n" <> "and a description on how to reproduce the bug."
src/Intro/Trustworthy.hs view
@@ -1,52 +1,56 @@ {-# LANGUAGE Trustworthy #-} module Intro.Trustworthy (- module X,- trace,- traceIO,- traceM,- traceShow,- traceShowM,- traceStack,- traceStackM,+ Data.DList.DList+ , GHC.Exts.IsList(+ Item+ , fromList+ -- , toList -- provided by Foldable+ )+ , trace+ , traceIO+ , traceM+ , traceShow+ , traceShowM+ , traceStack+ , traceStackM ) where -import Data.DList as X (- DList,- )--import GHC.Exts as X (- IsList(Item, fromList- -- , toList- )- )-+import qualified Data.DList+import qualified GHC.Exts import qualified Data.Text import qualified Debug.Trace -{-# WARNING trace "'trace' remains in code" #-}+-- | See 'Debug.trace.trace' trace :: Data.Text.Text -> a -> a trace = Debug.Trace.trace . Data.Text.unpack+{-# WARNING trace "'trace' remains in code" #-} -{-# WARNING traceStack "'traceStack' remains in code" #-}+-- | See 'Debug.trace.traceStack' traceStack :: Data.Text.Text -> a -> a traceStack = Debug.Trace.traceStack . Data.Text.unpack+{-# WARNING traceStack "'traceStack' remains in code" #-} -{-# WARNING traceStackM "'traceStackM' remains in code" #-}+-- | 'traceStack' lifted to a 'Monad' traceStackM :: Monad m => Data.Text.Text -> m () traceStackM s = traceStack s $ pure ()+{-# WARNING traceStackM "'traceStackM' remains in code" #-} -{-# WARNING traceShow "'traceShow' remains in code" #-}+-- | See 'Debug.Trace.traceShow' traceShow :: Show a => a -> b -> b traceShow = Debug.Trace.traceShow+{-# WARNING traceShow "'traceShow' remains in code" #-} -{-# WARNING traceShowM "'traceShowM' remains in code" #-}+-- | See 'Debug.Trace.traceShowM' traceShowM :: (Show a, Monad m) => a -> m () traceShowM = Debug.Trace.traceShowM+{-# WARNING traceShowM "'traceShowM' remains in code" #-} -{-# WARNING traceM "'traceM' remains in code" #-}+-- | See 'Debug.Trace.traceM' traceM :: Monad m => Data.Text.Text -> m () traceM = Debug.Trace.traceM . Data.Text.unpack+{-# WARNING traceM "'traceM' remains in code" #-} -{-# WARNING traceIO "'traceIO' remains in code" #-}+-- | See 'Debug.Trace.traceIO' traceIO :: Data.Text.Text -> IO () traceIO = Debug.Trace.traceIO . Data.Text.unpack+{-# WARNING traceIO "'traceIO' remains in code" #-}