rio-0.1.0.0: src/RIO/Prelude/Trace.hs

module RIO.Prelude.Trace
  ( -- * Text
    trace
  , traceId
  , traceIO
  , traceM
  , traceEvent
  , traceEventIO
  , traceMarker
  , traceMarkerIO
  , traceStack
    -- * Show
  , traceShow
  , traceShowId
  , traceShowIO
  , traceShowM
  , traceShowEvent
  , traceShowEventIO
  , traceShowMarker
  , traceShowMarkerIO
  , traceShowStack
    -- * Display
  , traceDisplay
  , traceDisplayId
  , traceDisplayIO
  , traceDisplayM
  , traceDisplayEvent
  , traceDisplayEventIO
  , traceDisplayMarker
  , traceDisplayMarkerIO
  , traceDisplayStack
  ) where

import qualified Debug.Trace as Trace

import           Control.Monad.IO.Class(MonadIO(..))
import           RIO.Prelude.Display
import           RIO.Text         (Text)
import qualified RIO.Text as Text

----------------------------------------------------
-- Text
----------------------------------------------------

{-# WARNING trace "Trace statement left in code" #-}
-- | @since 0.1.0.0
trace :: Text -> a -> a
trace = Trace.trace . Text.unpack

{-# WARNING traceId "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceId :: Text -> Text
traceId str = Trace.trace (Text.unpack str) str

{-# WARNING traceIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceIO :: MonadIO m => Text -> m ()
traceIO = liftIO . Trace.traceIO . Text.unpack

{-# WARNING traceM "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceM :: Applicative f => Text -> f ()
traceM = Trace.traceM . Text.unpack

{-# WARNING traceEvent "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceEvent :: Text -> a -> a
traceEvent = Trace.traceEvent . Text.unpack

{-# WARNING traceEventIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceEventIO :: MonadIO m => Text -> m ()
traceEventIO = liftIO . Trace.traceEventIO . Text.unpack

{-# WARNING traceMarker "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceMarker :: Text -> a -> a
traceMarker = Trace.traceMarker . Text.unpack

{-# WARNING traceMarkerIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceMarkerIO :: MonadIO m => Text -> m ()
traceMarkerIO = liftIO . Trace.traceMarkerIO . Text.unpack

{-# WARNING traceStack "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceStack :: Text -> a -> a
traceStack = Trace.traceStack . Text.unpack

----------------------------------------------------
-- Show
----------------------------------------------------

{-# WARNING traceShow "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShow :: Show a => a -> b -> b
traceShow = Trace.traceShow

{-# WARNING traceShowId "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowId :: Show a => a -> a
traceShowId = Trace.traceShowId

{-# WARNING traceShowIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowIO :: (Show a, MonadIO m) => a -> m ()
traceShowIO = liftIO . Trace.traceIO . show

{-# WARNING traceShowM "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowM :: (Show a, Applicative f) => a -> f ()
traceShowM = Trace.traceM . show

{-# WARNING traceShowEvent "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowEvent :: Show a => a -> b -> b
traceShowEvent = Trace.traceEvent . show

{-# WARNING traceShowEventIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowEventIO :: (Show a, MonadIO m) => a -> m ()
traceShowEventIO = liftIO . Trace.traceEventIO . show

{-# WARNING traceShowMarker "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowMarker :: Show a => a -> b -> b
traceShowMarker = Trace.traceMarker . show

{-# WARNING traceShowMarkerIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowMarkerIO :: (Show a, MonadIO m) => a -> m ()
traceShowMarkerIO = liftIO . Trace.traceMarkerIO . show

{-# WARNING traceShowStack "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceShowStack :: Show a => a -> b -> b
traceShowStack = Trace.traceStack . show

----------------------------------------------------
-- Display
----------------------------------------------------

{-# WARNING traceDisplay "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplay :: Display a => a -> b -> b
traceDisplay = trace . utf8BuilderToText . display

{-# WARNING traceDisplayId "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayId :: Display a => a -> a
traceDisplayId x = traceDisplay x x

{-# WARNING traceDisplayIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayIO :: (Display a, MonadIO m) => a -> m ()
traceDisplayIO = traceIO . utf8BuilderToText . display

{-# WARNING traceDisplayM "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayM :: (Display a, Applicative f) => a -> f ()
traceDisplayM = traceM . utf8BuilderToText . display

{-# WARNING traceDisplayEvent "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayEvent :: Display a => a -> b -> b
traceDisplayEvent = traceEvent . utf8BuilderToText . display

{-# WARNING traceDisplayEventIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayEventIO :: (Display a, MonadIO m) => a -> m ()
traceDisplayEventIO = traceEventIO . utf8BuilderToText . display

{-# WARNING traceDisplayMarker "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayMarker :: Display a => a -> b -> b
traceDisplayMarker = traceMarker . utf8BuilderToText . display

{-# WARNING traceDisplayMarkerIO "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayMarkerIO :: (Display a, MonadIO m) => a -> m ()
traceDisplayMarkerIO = traceMarkerIO . utf8BuilderToText . display

{-# WARNING traceDisplayStack "Trace statement left in code" #-}
-- | @since 0.1.0.0
traceDisplayStack :: Display a => a -> b -> b
traceDisplayStack = traceStack . utf8BuilderToText . display