module HaskellWorks.Polysemy.Hedgehog.Jot
  ( jotShow,
    jotShow_,
    jotWithCallstack,

    jot,
    jot_,
    jotText_,
    jotM,
    jotM_,
    jotBsUtf8M,
    jotLbsUtf8M,
    jotIO,
    jotIO_,
    jotShowM,
    jotShowM_,
    jotShowIO,
    jotShowIO_,
    jotShowRead,
    jotJson,
    jotJson_,
    jotJsonM,
    jotJsonM_,
    jotJsonPretty,
    jotJsonPretty_,
    jotJsonPrettyM,
    jotJsonPrettyM_,
    jotYaml,
    jotYaml_,
    jotYamlM,
    jotYamlM_,
    jotEach,
    jotEach_,
    jotEachM,
    jotEachM_,
    jotEachIO,
    jotEachIO_,

    jotPkgGoldenFile,
    jotPkgInputFile,
    jotRootInputFile,
    jotTempFile,

    jotShowDataLog,
    jotShowDataLogLocal,
  ) where

import           Data.Aeson                                     (ToJSON)

import qualified Data.Aeson                                     as J
import qualified Data.Aeson.Encode.Pretty                       as J
import qualified Data.ByteString.Lazy                           as LBS
import qualified Data.Text                                      as T
import qualified Data.Text                                      as Text
import qualified Data.Text.Encoding                             as T
import qualified Data.Text.Encoding                             as Text
import qualified Data.Text.Lazy                                 as LT
import qualified Data.Text.Lazy.Encoding                        as LT
import qualified Data.Yaml                                      as Y
import qualified GHC.Stack                                      as GHC
import           HaskellWorks.Polysemy.Prelude
import           Text.Read                                      (read)

import qualified Hedgehog.Internal.Property                     as H
import qualified Hedgehog.Internal.Source                       as H

import           HaskellWorks.Polysemy
import           HaskellWorks.Polysemy.Hedgehog.Effect.Hedgehog
import           HaskellWorks.Polysemy.Hedgehog.Workspace.Types
import           HaskellWorks.Polysemy.String
import           Polysemy
import           Polysemy.Internal.Tactics                      (liftT)
import qualified Polysemy.Log.Effect.DataLog                    as Log

-- | Annotate the given string at the context supplied by the callstack.
jotWithCallstack :: forall r. ()
  => Member Hedgehog r
  => GHC.CallStack
  -> String
  -> Sem r ()
jotWithCallstack :: forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
cs String
a =
  Log -> Sem r ()
forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
Log -> Sem r ()
writeLog (Log -> Sem r ()) -> Log -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Maybe Span -> String -> Log
H.Annotation (CallStack -> Maybe Span
H.getCaller CallStack
cs) String
a

-- | Annotate with the given string.
jot :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => String
  -> Sem r String
jot :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
String -> Sem r String
jot String
a = (HasCallStack => Sem r String) -> Sem r String
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r String) -> Sem r String)
-> (HasCallStack => Sem r String) -> Sem r String
forall a b. (a -> b) -> a -> b
$ do
  !String
b <- String -> Sem r String
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval String
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack String
b
  String -> Sem r String
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return String
b

-- | Annotate the given string returning unit.
jot_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToString a
  => a
  -> Sem r ()
jot_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToString a) =>
a -> Sem r ()
jot_ a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. ToString a => a -> String
toString a
a

-- | Annotate the given text returning unit.
jotText_ :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Text
  -> Sem r ()
jotText_ :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
Text -> Sem r ()
jotText_ Text
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
a

-- | Annotate the given string in a monadic context.
jotM :: forall a r. ()
  => ToString a
  => Member Hedgehog r
  => GHC.HasCallStack
  => Sem r a
  -> Sem r a
jotM :: forall a (r :: EffectRow).
(ToString a, Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
jotM Sem r a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. ToString a => a -> String
toString a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

jotBsUtf8M :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Sem r ByteString
  -> Sem r ByteString
jotBsUtf8M :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
Sem r ByteString -> Sem r ByteString
jotBsUtf8M Sem r ByteString
a = (HasCallStack => Sem r ByteString) -> Sem r ByteString
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ByteString) -> Sem r ByteString)
-> (HasCallStack => Sem r ByteString) -> Sem r ByteString
forall a b. (a -> b) -> a -> b
$ do
  !ByteString
b <- Sem r ByteString -> Sem r ByteString
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r ByteString
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
Text.decodeUtf8 ByteString
b
  ByteString -> Sem r ByteString
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
b

jotLbsUtf8M :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Sem r LBS.ByteString
  -> Sem r LBS.ByteString
jotLbsUtf8M :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
Sem r ByteString -> Sem r ByteString
jotLbsUtf8M Sem r ByteString
a = (HasCallStack => Sem r ByteString) -> Sem r ByteString
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ByteString) -> Sem r ByteString)
-> (HasCallStack => Sem r ByteString) -> Sem r ByteString
forall a b. (a -> b) -> a -> b
$ do
  !ByteString
b <- Sem r ByteString -> Sem r ByteString
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r ByteString
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 ByteString
b
  ByteString -> Sem r ByteString
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
b

-- | Annotate the given string in a monadic context returning unit.
jotM_ :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Sem r String
  -> Sem r ()
jotM_ :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
Sem r String -> Sem r ()
jotM_ Sem r String
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !String
b <- Sem r String -> Sem r String
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r String
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack String
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given string in IO.
jotIO :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => IO String
  -> Sem r String
jotIO :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
IO String -> Sem r String
jotIO IO String
f = (HasCallStack => Sem r String) -> Sem r String
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r String) -> Sem r String)
-> (HasCallStack => Sem r String) -> Sem r String
forall a b. (a -> b) -> a -> b
$ do
  !String
a <- IO String -> Sem r String
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
IO a -> Sem r a
evalIO IO String
f
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack String
a
  String -> Sem r String
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return String
a

-- | Annotate the given string in IO returning unit.
jotIO_ :: forall r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => IO String
  -> Sem r ()
jotIO_ :: forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
IO String -> Sem r ()
jotIO_ IO String
f = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !String
a <- IO String -> Sem r String
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
IO a -> Sem r a
evalIO IO String
f
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack String
a
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value.
jotShow :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => a
  -> Sem r a
jotShow :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
a -> Sem r a
jotShow a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
b)
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value returning unit.
jotShow_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => a
  -> Sem r ()
jotShow_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
a -> Sem r ()
jotShow_ a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)

-- | Annotate the given value in a monadic context.
jotShowM :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Sem r a
  -> Sem r a
jotShowM :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
Sem r a -> Sem r a
jotShowM Sem r a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
b)
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value in a monadic context returning unit.
jotShowM_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Sem r a
  -> Sem r ()
jotShowM_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
Sem r a -> Sem r ()
jotShowM_ Sem r a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
b)
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value in IO.
jotShowIO :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => IO a
  -> Sem r a
jotShowIO :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
IO a -> Sem r a
jotShowIO IO a
f = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
a <- IO a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
IO a -> Sem r a
evalIO IO a
f
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a

-- | Annotate the given value in IO returning unit.
jotShowIO_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => IO a
  -> Sem r ()
jotShowIO_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
IO a -> Sem r ()
jotShowIO_ IO a
f = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
a <- IO a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
IO a -> Sem r a
evalIO IO a
f
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value.
jotShowRead :: forall a r. ()
  => HasCallStack
  => Member Hedgehog r
  => Read a
  => Show a
  => String
  -> Sem r a
jotShowRead :: forall a (r :: EffectRow).
(HasCallStack, Member Hedgehog r, Read a, Show a) =>
String -> Sem r a
jotShowRead String
s = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
a <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval (forall a. Read a => String -> a
read @a String
s)
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a

-- | Annotate the given value as JSON.
jotJson :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => a
  -> Sem r a
jotJson :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
a -> Sem r a
jotJson a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encode a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value as JSON.
jotJson_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => a
  -> Sem r ()
jotJson_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
a -> Sem r ()
jotJson_ a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encode a
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value as JSON in a monadic context.
jotJsonM :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => Sem r a
  -> Sem r a
jotJsonM :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
Sem r a -> Sem r a
jotJsonM Sem r a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encode a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value as JSON in a monadic context.
jotJsonM_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => Sem r a
  -> Sem r ()
jotJsonM_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
Sem r a -> Sem r ()
jotJsonM_ Sem r a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encode a
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value as JSON.
jotJsonPretty :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => a
  -> Sem r a
jotJsonPretty :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
a -> Sem r a
jotJsonPretty a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encodePretty a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value as JSON.
jotJsonPretty_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => a
  -> Sem r ()
jotJsonPretty_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
a -> Sem r ()
jotJsonPretty_ a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encodePretty a
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value as JSON in a monadic context.
jotJsonPrettyM :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => Sem r a
  -> Sem r a
jotJsonPrettyM :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
Sem r a -> Sem r a
jotJsonPrettyM Sem r a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encodePretty a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value as JSON in a monadic context.
jotJsonPrettyM_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => Sem r a
  -> Sem r ()
jotJsonPrettyM_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
Sem r a -> Sem r ()
jotJsonPrettyM_ Sem r a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
LT.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
LT.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
J.encodePretty a
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value as JSON.
jotYaml :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => a
  -> Sem r a
jotYaml :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
a -> Sem r a
jotYaml a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
T.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
Y.encode a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value as JSON.
jotYaml_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => a
  -> Sem r ()
jotYaml_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
a -> Sem r ()
jotYaml_ a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
a -> Sem r a
eval a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
T.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
Y.encode a
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the given value as JSON in a monadic context.
jotYamlM :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => Sem r a
  -> Sem r a
jotYamlM :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
Sem r a -> Sem r a
jotYamlM Sem r a
a = (HasCallStack => Sem r a) -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r a) -> Sem r a)
-> (HasCallStack => Sem r a) -> Sem r a
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
T.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
Y.encode a
b
  a -> Sem r a
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
b

-- | Annotate the given value as JSON in a monadic context.
jotYamlM_ :: forall a r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => ToJSON a
  => Sem r a
  -> Sem r ()
jotYamlM_ :: forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToJSON a) =>
Sem r a -> Sem r ()
jotYamlM_ Sem r a
a = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !a
b <- Sem r a -> Sem r a
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
Sem r a -> Sem r a
evalM Sem r a
a
  CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
T.decodeUtf8 (ByteString -> Text) -> ByteString -> Text
forall a b. (a -> b) -> a -> b
$ a -> ByteString
forall a. ToJSON a => a -> ByteString
Y.encode a
b
  () -> Sem r ()
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Annotate the each value in the given traversable.
jotEach :: forall a f r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Traversable f
  => f a
  -> Sem r (f a)
jotEach :: forall a (f :: * -> *) (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a, Traversable f) =>
f a -> Sem r (f a)
jotEach f a
as = (HasCallStack => Sem r (f a)) -> Sem r (f a)
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r (f a)) -> Sem r (f a))
-> (HasCallStack => Sem r (f a)) -> Sem r (f a)
forall a b. (a -> b) -> a -> b
$ do
  f a -> (a -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Sem r ()) -> Sem r ()) -> (a -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> (a -> String) -> a -> Sem r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show
  f a -> Sem r (f a)
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return f a
as

-- | Annotate the each value in the given traversable returning unit.
jotEach_ :: forall a f r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Traversable f
  => f a
  -> Sem r ()
jotEach_ :: forall a (f :: * -> *) (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a, Traversable f) =>
f a -> Sem r ()
jotEach_ f a
as = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ f a -> (a -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Sem r ()) -> Sem r ()) -> (a -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> (a -> String) -> a -> Sem r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show

-- | Annotate the each value in the given traversable in a monadic context.
jotEachM :: forall a f r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Traversable f
  => Sem r (f a)
  -> Sem r (f a)
jotEachM :: forall a (f :: * -> *) (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a, Traversable f) =>
Sem r (f a) -> Sem r (f a)
jotEachM Sem r (f a)
f = (HasCallStack => Sem r (f a)) -> Sem r (f a)
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r (f a)) -> Sem r (f a))
-> (HasCallStack => Sem r (f a)) -> Sem r (f a)
forall a b. (a -> b) -> a -> b
$ do
  !f a
as <- Sem r (f a)
f
  f a -> (a -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Sem r ()) -> Sem r ()) -> (a -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> (a -> String) -> a -> Sem r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show
  f a -> Sem r (f a)
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return f a
as

-- | Annotate the each value in the given traversable in a monadic context returning unit.
jotEachM_ :: forall a f r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Traversable f
  => Sem r (f a)
  -> Sem r ()
jotEachM_ :: forall a (f :: * -> *) (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a, Traversable f) =>
Sem r (f a) -> Sem r ()
jotEachM_ Sem r (f a)
f = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !f a
as <- Sem r (f a)
f
  f a -> (a -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Sem r ()) -> Sem r ()) -> (a -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> (a -> String) -> a -> Sem r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show

-- | Annotate the each value in the given traversable in IO.
jotEachIO :: forall a f r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Traversable f
  => IO (f a)
  -> Sem r (f a)
jotEachIO :: forall a (f :: * -> *) (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a, Traversable f) =>
IO (f a) -> Sem r (f a)
jotEachIO IO (f a)
f = (HasCallStack => Sem r (f a)) -> Sem r (f a)
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r (f a)) -> Sem r (f a))
-> (HasCallStack => Sem r (f a)) -> Sem r (f a)
forall a b. (a -> b) -> a -> b
$ do
  !f a
as <- IO (f a) -> Sem r (f a)
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
IO a -> Sem r a
evalIO IO (f a)
f
  f a -> (a -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Sem r ()) -> Sem r ()) -> (a -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> (a -> String) -> a -> Sem r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show
  f a -> Sem r (f a)
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return f a
as

-- | Annotate the each value in the given traversable in IO returning unit.
jotEachIO_ :: forall a f r. ()
  => Member Hedgehog r
  => GHC.HasCallStack
  => Show a
  => Traversable f
  => IO (f a)
  -> Sem r ()
jotEachIO_ :: forall a (f :: * -> *) (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a, Traversable f) =>
IO (f a) -> Sem r ()
jotEachIO_ IO (f a)
f = (HasCallStack => Sem r ()) -> Sem r ()
forall a. HasCallStack => (HasCallStack => a) -> a
GHC.withFrozenCallStack ((HasCallStack => Sem r ()) -> Sem r ())
-> (HasCallStack => Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ do
  !f a
as <- IO (f a) -> Sem r (f a)
forall (r :: EffectRow) a.
(Member Hedgehog r, HasCallStack) =>
IO a -> Sem r a
evalIO IO (f a)
f
  f a -> (a -> Sem r ()) -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Sem r ()) -> Sem r ()) -> (a -> Sem r ()) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Sem r ()
forall (r :: EffectRow).
Member Hedgehog r =>
CallStack -> String -> Sem r ()
jotWithCallstack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Sem r ()) -> (a -> String) -> a -> Sem r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show

-- | Return the input file path after annotating it relative to the package directory
jotPkgInputFile :: forall r. ()
  => HasCallStack
  => Member Hedgehog r
  => Member (Reader PackagePath) r
  => FilePath
  -> Sem r FilePath
jotPkgInputFile :: forall (r :: EffectRow).
(HasCallStack, Member Hedgehog r, Member (Reader PackagePath) r) =>
String -> Sem r String
jotPkgInputFile String
fp = (HasCallStack => Sem r String) -> Sem r String
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Sem r String) -> Sem r String)
-> (HasCallStack => Sem r String) -> Sem r String
forall a b. (a -> b) -> a -> b
$ do
  PackagePath { $sel:filePath:PackagePath :: PackagePath -> String
filePath = String
pkgPath } <- Sem r PackagePath
forall i (r :: EffectRow). Member (Reader i) r => Sem r i
ask
  String -> Sem r ()
forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToString a) =>
a -> Sem r ()
jot_ (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
pkgPath String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"/" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
fp
  String -> Sem r String
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return String
fp

-- | Return the golden file path after annotating it relative to the package directory
jotPkgGoldenFile :: forall r. ()
  => HasCallStack
  => Member Hedgehog r
  => Member (Reader PackagePath) r
  => FilePath
  -> Sem r FilePath
jotPkgGoldenFile :: forall (r :: EffectRow).
(HasCallStack, Member Hedgehog r, Member (Reader PackagePath) r) =>
String -> Sem r String
jotPkgGoldenFile String
fp = (HasCallStack => Sem r String) -> Sem r String
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Sem r String) -> Sem r String)
-> (HasCallStack => Sem r String) -> Sem r String
forall a b. (a -> b) -> a -> b
$ do
  PackagePath { $sel:filePath:PackagePath :: PackagePath -> String
filePath = String
pkgPath } <- Sem r PackagePath
forall i (r :: EffectRow). Member (Reader i) r => Sem r i
ask
  String -> Sem r ()
forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToString a) =>
a -> Sem r ()
jot_ (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
pkgPath String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"/" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
fp
  String -> Sem r String
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return String
fp

jotRootInputFile :: forall r. ()
  => HasCallStack
  => Member Hedgehog r
  => Member (Reader ProjectRoot) r
  => FilePath
  -> Sem r FilePath
jotRootInputFile :: forall (r :: EffectRow).
(HasCallStack, Member Hedgehog r, Member (Reader ProjectRoot) r) =>
String -> Sem r String
jotRootInputFile String
fp = (HasCallStack => Sem r String) -> Sem r String
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Sem r String) -> Sem r String)
-> (HasCallStack => Sem r String) -> Sem r String
forall a b. (a -> b) -> a -> b
$ do
  ProjectRoot { $sel:filePath:ProjectRoot :: ProjectRoot -> String
filePath = String
pkgPath } <- Sem r ProjectRoot
forall i (r :: EffectRow). Member (Reader i) r => Sem r i
ask
  String -> Sem r String
forall (r :: EffectRow).
(Member Hedgehog r, HasCallStack) =>
String -> Sem r String
jot (String -> Sem r String) -> String -> Sem r String
forall a b. (a -> b) -> a -> b
$ String
pkgPath String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"/" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
fp

-- | Return the test file path after annotating it relative to the project root directory
jotTempFile :: forall r. ()
  => HasCallStack
  => Member Hedgehog r
  => Member (Reader Workspace) r
  => FilePath
  -> Sem r FilePath
jotTempFile :: forall (r :: EffectRow).
(HasCallStack, Member Hedgehog r, Member (Reader Workspace) r) =>
String -> Sem r String
jotTempFile String
fp = (HasCallStack => Sem r String) -> Sem r String
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Sem r String) -> Sem r String)
-> (HasCallStack => Sem r String) -> Sem r String
forall a b. (a -> b) -> a -> b
$ do
  Workspace { $sel:filePath:Workspace :: Workspace -> String
filePath = String
workspace } <- Sem r Workspace
forall i (r :: EffectRow). Member (Reader i) r => Sem r i
ask
  let relPath :: String
relPath = String
workspace String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"/" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
fp
  String -> Sem r ()
forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, ToString a) =>
a -> Sem r ()
jot_ (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
workspace String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"/" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
relPath
  String -> Sem r String
forall a. a -> Sem r a
forall (m :: * -> *) a. Monad m => a -> m a
return String
relPath

jotShowDataLog :: forall a r. ()
  => HasCallStack
  => Show a
  => Member Hedgehog r
  => InterpreterFor (DataLog a) r
jotShowDataLog :: forall a (r :: EffectRow).
(HasCallStack, Show a, Member Hedgehog r) =>
InterpreterFor (DataLog a) r
jotShowDataLog =
  (HasCallStack => Sem (DataLog a : r) a -> Sem r a)
-> Sem (DataLog a : r) a -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Sem (DataLog a : r) a -> Sem r a)
 -> Sem (DataLog a : r) a -> Sem r a)
-> (HasCallStack => Sem (DataLog a : r) a -> Sem r a)
-> Sem (DataLog a : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$
    (a -> a) -> InterpreterFor (DataLog a) r
forall a (r :: EffectRow).
(HasCallStack, Show a, Member Hedgehog r) =>
(a -> a) -> InterpreterFor (DataLog a) r
jotShowDataLogLocal a -> a
forall a. a -> a
id
{-# inline jotShowDataLog #-}

jotShowDataLogLocal :: forall a r. ()
  => HasCallStack
  => Show a
  => Member Hedgehog r
  => (a -> a)
  -> InterpreterFor (DataLog a) r
jotShowDataLogLocal :: forall a (r :: EffectRow).
(HasCallStack, Show a, Member Hedgehog r) =>
(a -> a) -> InterpreterFor (DataLog a) r
jotShowDataLogLocal a -> a
context =
  (HasCallStack => Sem (DataLog a : r) a -> Sem r a)
-> Sem (DataLog a : r) a -> Sem r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Sem (DataLog a : r) a -> Sem r a)
 -> Sem (DataLog a : r) a -> Sem r a)
-> (HasCallStack => Sem (DataLog a : r) a -> Sem r a)
-> Sem (DataLog a : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$
    (forall (rInitial :: EffectRow) x.
 DataLog a (Sem rInitial) x
 -> Tactical (DataLog a) (Sem rInitial) r x)
-> Sem (DataLog a : r) a -> Sem r a
forall (e :: Effect) (r :: EffectRow) a.
(forall (rInitial :: EffectRow) x.
 e (Sem rInitial) x -> Tactical e (Sem rInitial) r x)
-> Sem (e : r) a -> Sem r a
interpretH \case
      Log.DataLog a
a ->
        Sem r x -> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall (m :: * -> *) (f :: * -> *) (r :: EffectRow) (e :: Effect)
       a.
Functor f =>
Sem r a -> Sem (WithTactics e f m r) (f a)
liftT (a -> Sem r ()
forall a (r :: EffectRow).
(Member Hedgehog r, HasCallStack, Show a) =>
a -> Sem r ()
jotShow_ (a -> a
context a
a))
      Log.Local a -> a
f Sem rInitial x
ma ->
        Sem r (f x)
-> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall (e :: Effect) (r :: EffectRow) a. Sem r a -> Sem (e : r) a
raise (Sem r (f x)
 -> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x))
-> (Sem (DataLog a : r) (f x) -> Sem r (f x))
-> Sem (DataLog a : r) (f x)
-> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a) -> InterpreterFor (DataLog a) r
forall a (r :: EffectRow).
(HasCallStack, Show a, Member Hedgehog r) =>
(a -> a) -> InterpreterFor (DataLog a) r
jotShowDataLogLocal (a -> a
f (a -> a) -> (a -> a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
context) (Sem (DataLog a : r) (f x)
 -> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x))
-> Sem
     (WithTactics (DataLog a) f (Sem rInitial) r)
     (Sem (DataLog a : r) (f x))
-> Sem (WithTactics (DataLog a) f (Sem rInitial) r) (f x)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Sem rInitial x
-> Sem
     (WithTactics (DataLog a) f (Sem rInitial) r)
     (Sem (DataLog a : r) (f x))
forall (m :: * -> *) a (e :: Effect) (f :: * -> *)
       (r :: EffectRow).
m a -> Sem (WithTactics e f m r) (Sem (e : r) (f a))
runT Sem rInitial x
ma
{-# inline jotShowDataLogLocal #-}