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,

    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.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

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