module Effectful.Zoo.Hedgehog.Api.Journal
  ( jot,
    jot_,
    
    jotWithCallStack,

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

    jotLogTextWithCallStack,

    jotShowDataLog,

    writeLog,
  ) where

import Data.Aeson (ToJSON(..))
import Data.Aeson qualified as J
import Data.Aeson.Encode.Pretty qualified as J
import Data.ByteString.Lazy qualified as LBS
import Data.Text qualified as T
import Data.Text.Encoding qualified as T
import Data.Text.Lazy qualified as LT
import Data.Text.Lazy.Encoding qualified as LT
import Data.Traversable
import Data.Yaml qualified as Y
import Effectful
import Effectful.Dispatch.Dynamic
import Effectful.Zoo.Core
import Effectful.Zoo.DataLog.Dynamic
import Effectful.Zoo.DataLog.Dynamic qualified as DataLog
import Effectful.Zoo.Hedgehog.Api.Eval
import Effectful.Zoo.Hedgehog.Api.Failure
import Effectful.Zoo.Hedgehog.Dynamic
import Effectful.Zoo.Log.Data.Severity
import GHC.Stack qualified as GHC
import HaskellWorks.Prelude
import HaskellWorks.String
import HaskellWorks.ToText
import Hedgehog.Internal.Property qualified as H
import Hedgehog.Internal.Source qualified as H

-- | Annotate the given string at the context supplied by the callstack.
jotWithCallStack :: forall r. ()
  => r <: Hedgehog
  => CallStack
  -> String
  -> Eff r ()
jotWithCallStack :: forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
cs String
a =
  Log -> Eff r ()
forall (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Log -> Eff r ()
writeLog (Log -> Eff r ()) -> Log -> Eff 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. ()
  => r <: Hedgehog
  => HasCallStack
  => String
  -> Eff r String
jot :: forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
String -> Eff r String
jot String
a =
  (HasCallStack => Eff r String) -> Eff r String
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !String
b <- String -> Eff r String
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval String
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack String
b
    return String
b

-- | Annotate the given string returning unit.
jot_ :: forall r. ()
  => r <: Hedgehog
  => HasCallStack
  => Text
  -> Eff r ()
jot_ :: forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
Text -> Eff r ()
jot_ =
  (HasCallStack => Text -> Eff r ()) -> Text -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    Text -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
Text -> Eff r ()
jotText_

-- | Annotate the given text returning unit.
jotText_ :: forall r. ()
  => r <: Hedgehog
  => HasCallStack
  => Text
  -> Eff r ()
jotText_ :: forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
Text -> Eff r ()
jotText_ Text
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
a

-- | Annotate the given string in a monadic context.
jotM :: forall a r. ()
  => ToString a
  => r <: Hedgehog
  => HasCallStack
  => Eff r a
  -> Eff r a
jotM :: forall a (r :: [Effect]).
(ToString a, r <: Hedgehog, HasCallStack) =>
Eff r a -> Eff r a
jotM Eff r a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff r ()
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. ToString a => a -> String
toString a
b
    return a
b

jotBsUtf8M :: forall r. ()
  => r <: Hedgehog
  => HasCallStack
  => Eff r ByteString
  -> Eff r ByteString
jotBsUtf8M :: forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
Eff r ByteString -> Eff r ByteString
jotBsUtf8M Eff r ByteString
a =
  (HasCallStack => Eff r ByteString) -> Eff r ByteString
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !ByteString
b <- Eff r ByteString -> Eff r ByteString
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r ByteString
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
b
    return ByteString
b

jotLbsUtf8M :: forall r. ()
  => r <: Hedgehog
  => HasCallStack
  => Eff r LBS.ByteString
  -> Eff r LBS.ByteString
jotLbsUtf8M :: forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
Eff r ByteString -> Eff r ByteString
jotLbsUtf8M Eff r ByteString
a =
  (HasCallStack => Eff r ByteString) -> Eff r ByteString
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !ByteString
b <- Eff r ByteString -> Eff r ByteString
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r ByteString
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ByteString
b

-- | Annotate the given string in a monadic context returning unit.
jotM_ :: forall r. ()
  => r <: Hedgehog
  => HasCallStack
  => Eff r String
  -> Eff r ()
jotM_ :: forall (r :: [Effect]).
(r <: Hedgehog, HasCallStack) =>
Eff r String -> Eff r ()
jotM_ Eff r String
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !String
b <- Eff r String -> Eff r String
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r String
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack String
b
    return ()

-- | Annotate the given string in IO.
jotIO :: forall r. ()
  => r <: Hedgehog
  => r <: IOE
  => HasCallStack
  => IO String
  -> Eff r String
jotIO :: forall (r :: [Effect]).
(r <: Hedgehog, r <: IOE, HasCallStack) =>
IO String -> Eff r String
jotIO IO String
f =
  (HasCallStack => Eff r String) -> Eff r String
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !String
a <- IO String -> Eff r String
forall a (r :: [Effect]).
(HasCallStack, r <: IOE, r <: Hedgehog) =>
IO a -> Eff r a
evalIO IO String
f
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack String
a
    return String
a

-- | Annotate the given string in IO returning unit.
jotIO_ :: forall r. ()
  => r <: Hedgehog
  => r <: IOE
  => HasCallStack
  => IO String
  -> Eff r ()
jotIO_ :: forall (r :: [Effect]).
(r <: Hedgehog, r <: IOE, HasCallStack) =>
IO String -> Eff r ()
jotIO_ IO String
f =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !String
a <- IO String -> Eff r String
forall a (r :: [Effect]).
(HasCallStack, r <: IOE, r <: Hedgehog) =>
IO a -> Eff r a
evalIO IO String
f
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack String
a
    return ()

-- | Annotate the given value.
jotShow :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => a
  -> Eff r a
jotShow :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a) =>
a -> Eff r a
jotShow a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
b)
    return a
b

-- | Annotate the given value returning unit.
jotShow_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => a
  -> Eff r ()
jotShow_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a) =>
a -> Eff r ()
jotShow_ a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff 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. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => Eff r a
  -> Eff r a
jotShowM :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a) =>
Eff r a -> Eff r a
jotShowM Eff r a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
b)
    return a
b

-- | Annotate the given value in a monadic context returning unit.
jotShowM_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => Eff r a
  -> Eff r ()
jotShowM_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a) =>
Eff r a -> Eff r ()
jotShowM_ Eff r a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
b)
    return ()

-- | Annotate the given value in IO.
jotShowIO :: forall a r. ()
  => r <: Hedgehog
  => r <: IOE
  => HasCallStack
  => Show a
  => IO a
  -> Eff r a
jotShowIO :: forall a (r :: [Effect]).
(r <: Hedgehog, r <: IOE, HasCallStack, Show a) =>
IO a -> Eff r a
jotShowIO IO a
f =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
a <- IO a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: IOE, r <: Hedgehog) =>
IO a -> Eff r a
evalIO IO a
f
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)
    return a
a

-- | Annotate the given value in IO returning unit.
jotShowIO_ :: forall a r. ()
  => r <: Hedgehog
  => r <: IOE
  => HasCallStack
  => Show a
  => IO a
  -> Eff r ()
jotShowIO_ :: forall a (r :: [Effect]).
(r <: Hedgehog, r <: IOE, HasCallStack, Show a) =>
IO a -> Eff r ()
jotShowIO_ IO a
f =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
a <- IO a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: IOE, r <: Hedgehog) =>
IO a -> Eff r a
evalIO IO a
f
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)
    return ()

-- | Annotate the given value.
jotShowRead :: forall a r. ()
  => HasCallStack
  => r <: Hedgehog
  => Read a
  => Show a
  => String
  -> Eff r a
jotShowRead :: forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog, Read a, Show a) =>
String -> Eff r a
jotShowRead String
s =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !Either String a
result <- Either String a -> Eff r (Either String a)
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval (forall a. Read a => String -> Either String a
readEither @a String
s)
    case Either String a
result of
      Left String
e -> Maybe Diff -> String -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Maybe Diff -> String -> Eff r a
failWith Maybe Diff
forall a. Maybe a
Nothing (String -> Eff r a) -> String -> Eff r a
forall a b. (a -> b) -> a -> b
$ String
"Failed to parse: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String -> String
forall a. Show a => a -> String
show String
s String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" with error: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String -> String
forall a. Show a => a -> String
show String
e
      Right a
a -> do
        CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (a -> String
forall a. Show a => a -> String
show a
a)
        return a
a

-- | Annotate the given value as JSON.
jotJson :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => a
  -> Eff r a
jotJson :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
a -> Eff r a
jotJson a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return a
b

-- | Annotate the given value as JSON.
jotJson_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => a
  -> Eff r ()
jotJson_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
a -> Eff r ()
jotJson_ a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ()

-- | Annotate the given value as JSON in a monadic context.
jotJsonM :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => Eff r a
  -> Eff r a
jotJsonM :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
Eff r a -> Eff r a
jotJsonM Eff r a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return a
b

-- | Annotate the given value as JSON in a monadic context.
jotJsonM_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => Eff r a
  -> Eff r ()
jotJsonM_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
Eff r a -> Eff r ()
jotJsonM_ Eff r a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ()

-- | Annotate the given value as JSON.
jotJsonPretty :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => a
  -> Eff r a
jotJsonPretty :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
a -> Eff r a
jotJsonPretty a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return a
b

-- | Annotate the given value as JSON.
jotJsonPretty_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => a
  -> Eff r ()
jotJsonPretty_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
a -> Eff r ()
jotJsonPretty_ a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ()

-- | Annotate the given value as JSON in a monadic context.
jotJsonPrettyM :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => Eff r a
  -> Eff r a
jotJsonPrettyM :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
Eff r a -> Eff r a
jotJsonPrettyM Eff r a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return a
b

-- | Annotate the given value as JSON in a monadic context.
jotJsonPrettyM_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => Eff r a
  -> Eff r ()
jotJsonPrettyM_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
Eff r a -> Eff r ()
jotJsonPrettyM_ Eff r a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ()

-- | Annotate the given value as JSON.
jotYaml :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => a
  -> Eff r a
jotYaml :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
a -> Eff r a
jotYaml a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return a
b

-- | Annotate the given value as JSON.
jotYaml_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => a
  -> Eff r ()
jotYaml_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
a -> Eff r ()
jotYaml_ a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
a -> Eff r a
eval a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ()

-- | Annotate the given value as JSON in a monadic context.
jotYamlM :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => Eff r a
  -> Eff r a
jotYamlM :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
Eff r a -> Eff r a
jotYamlM Eff r a
a =
  (HasCallStack => Eff r a) -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return a
b

-- | Annotate the given value as JSON in a monadic context.
jotYamlM_ :: forall a r. ()
  => r <: Hedgehog
  => HasCallStack
  => ToJSON a
  => Eff r a
  -> Eff r ()
jotYamlM_ :: forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, ToJSON a) =>
Eff r a -> Eff r ()
jotYamlM_ Eff r a
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !a
b <- Eff r a -> Eff r a
forall a (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Eff r a -> Eff r a
evalM Eff r a
a
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> String -> Eff 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
    return ()

-- | Annotate the each value in the given traversable.
jotEach :: forall a f r. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => Traversable f
  => f a
  -> Eff r (f a)
jotEach :: forall a (f :: * -> *) (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a, Traversable f) =>
f a -> Eff r (f a)
jotEach f a
as =
  (HasCallStack => Eff r (f a)) -> Eff r (f a)
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    f a -> (a -> Eff r ()) -> Eff r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Eff r ()) -> Eff r ()) -> (a -> Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> (a -> String) -> a -> Eff r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show
    return f a
as

-- | Annotate the each value in the given traversable returning unit.
jotEach_ :: forall a f r. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => Traversable f
  => f a
  -> Eff r ()
jotEach_ :: forall a (f :: * -> *) (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a, Traversable f) =>
f a -> Eff r ()
jotEach_ f a
as =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Eff r ()) -> Eff r ())
-> (HasCallStack => Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$ f a -> (a -> Eff r ()) -> Eff r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Eff r ()) -> Eff r ()) -> (a -> Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> (a -> String) -> a -> Eff 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. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => Traversable f
  => Eff r (f a)
  -> Eff r (f a)
jotEachM :: forall a (f :: * -> *) (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a, Traversable f) =>
Eff r (f a) -> Eff r (f a)
jotEachM Eff r (f a)
f =
  (HasCallStack => Eff r (f a)) -> Eff r (f a)
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !f a
as <- Eff r (f a)
f
    f a -> (a -> Eff r ()) -> Eff r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Eff r ()) -> Eff r ()) -> (a -> Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> (a -> String) -> a -> Eff r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show
    return f a
as

-- | Annotate the each value in the given traversable in a monadic context returning unit.
jotEachM_ :: forall a f r. ()
  => r <: Hedgehog
  => HasCallStack
  => Show a
  => Traversable f
  => Eff r (f a)
  -> Eff r ()
jotEachM_ :: forall a (f :: * -> *) (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a, Traversable f) =>
Eff r (f a) -> Eff r ()
jotEachM_ Eff r (f a)
f =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !f a
as <- Eff r (f a)
f
    f a -> (a -> Eff r ()) -> Eff r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Eff r ()) -> Eff r ()) -> (a -> Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> (a -> String) -> a -> Eff 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. ()
  => r <: Hedgehog
  => r <: IOE
  => HasCallStack
  => Show a
  => Traversable f
  => IO (f a)
  -> Eff r (f a)
jotEachIO :: forall a (f :: * -> *) (r :: [Effect]).
(r <: Hedgehog, r <: IOE, HasCallStack, Show a, Traversable f) =>
IO (f a) -> Eff r (f a)
jotEachIO IO (f a)
f =
  (HasCallStack => Eff r (f a)) -> Eff r (f a)
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    !f a
as <- IO (f a) -> Eff r (f a)
forall a (r :: [Effect]).
(HasCallStack, r <: IOE, r <: Hedgehog) =>
IO a -> Eff r a
evalIO IO (f a)
f
    f a -> (a -> Eff r ()) -> Eff r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ f a
as ((a -> Eff r ()) -> Eff r ()) -> (a -> Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$ CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
HasCallStack => CallStack
GHC.callStack (String -> Eff r ()) -> (a -> String) -> a -> Eff r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show
    return f a
as

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

jotLogTextWithCallStack :: forall r. ()
  => r <: Hedgehog
  => CallStack
  -> Severity
  -> Text
  -> Eff r ()
jotLogTextWithCallStack :: forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> Severity -> Text -> Eff r ()
jotLogTextWithCallStack CallStack
cs Severity
severity Text
a =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack do
    CallStack -> String -> Eff r ()
forall (r :: [Effect]).
(r <: Hedgehog) =>
CallStack -> String -> Eff r ()
jotWithCallStack CallStack
cs (String -> Eff r ()) -> String -> Eff r ()
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ Text
"[" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Severity -> Text
forall a. ToText a => a -> Text
toText Severity
severity Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"] " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
a

jotShowDataLog :: forall i a r. ()
  => HasCallStack
  => Show i
  => r <: Hedgehog
  => Eff (DataLog i : r) a
  -> Eff r a
jotShowDataLog :: forall i a (r :: [Effect]).
(HasCallStack, Show i, r <: Hedgehog) =>
Eff (DataLog i : r) a -> Eff r a
jotShowDataLog =
  (HasCallStack => Eff (DataLog i : r) a -> Eff r a)
-> Eff (DataLog i : r) a -> Eff r a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Eff (DataLog i : r) a -> Eff r a)
 -> Eff (DataLog i : r) a -> Eff r a)
-> (HasCallStack => Eff (DataLog i : r) a -> Eff r a)
-> Eff (DataLog i : r) a
-> Eff r a
forall a b. (a -> b) -> a -> b
$
    (HasCallStack => i -> Eff r ()) -> Eff (DataLog i : r) a -> Eff r a
forall i (r :: [Effect]) a.
HasCallStack =>
(HasCallStack => i -> Eff r ()) -> Eff (DataLog i : r) a -> Eff r a
DataLog.runDataLog i -> Eff r ()
HasCallStack => i -> Eff r ()
forall a (r :: [Effect]).
(r <: Hedgehog, HasCallStack, Show a) =>
a -> Eff r ()
jotShow_
{-# inline jotShowDataLog #-}

writeLog :: forall r. ()
  => HasCallStack
  => r <: Hedgehog
  => H.Log
  -> Eff r ()
writeLog :: forall (r :: [Effect]).
(HasCallStack, r <: Hedgehog) =>
Log -> Eff r ()
writeLog Log
message =
  (HasCallStack => Eff r ()) -> Eff r ()
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => Eff r ()) -> Eff r ())
-> (HasCallStack => Eff r ()) -> Eff r ()
forall a b. (a -> b) -> a -> b
$
    Log -> Eff r ()
forall (m :: * -> *). MonadTest m => Log -> m ()
H.writeLog Log
message