{- -----------------------------------------------------------------------------
Copyright 2020-2021 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE Safe #-}

module Test.TrackedErrors (tests) where

import Control.Arrow (first)
import Control.Monad.Writer

import Base.CompilerError
import Base.TrackedErrors


tests :: [IO (TrackedErrors ())]
tests :: [IO (TrackedErrors ())]
tests = [
    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    [Char] -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n" ([Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO Char),
    [Char] -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"" (TrackedErrorsIO Char
forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM :: TrackedErrorsIO Char),

    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char
'a',Char
'b']          ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAllM [Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess []                 ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAllM [] :: TrackedErrorsIO [Char]),
    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   [Char]
"error1\nerror2\n" ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAllM [[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char]
"ab" ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAnyM [Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char]
""   ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAnyM [] :: TrackedErrorsIO [Char]),
    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char]
"b"  ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAnyM [[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' ([TrackedErrorsIO Char] -> TrackedErrorsIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO a
collectFirstM [Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    [Char] -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   [Char]
""  ([TrackedErrorsIO Char] -> TrackedErrorsIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO a
collectFirstM [] :: TrackedErrorsIO Char),
    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'b' ([TrackedErrorsIO Char] -> TrackedErrorsIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO a
collectFirstM [[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    [Char] -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"warning1\nwarning2\n" ()
      ([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning1" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrorsIO ()
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return () TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning2"),
    [Char] -> [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"warning1\n" [Char]
"error\n"
      ([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning1" TrackedErrorsIO ()
-> TrackedErrorsT IO Any -> TrackedErrorsT IO Any
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsT IO Any
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" TrackedErrorsT IO Any -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning2" :: TrackedErrorsIO ()),

    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char
'a',Char
'b']  ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess []         ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [] :: TrackedErrorsIO [Char]),
    [Char] -> TrackedErrorsIO [Char] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   [Char]
"error1\n" ([TrackedErrorsIO Char] -> TrackedErrorsIO [Char]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',[Char] -> TrackedErrorsIO Char
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' TrackedErrorsIO Char -> [Char] -> TrackedErrorsIO Char
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message"),
    [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"message\n  error\n" ([Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),
    [Char] -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"message\n  warning\n" ()
      ([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),
    [Char] -> [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"message\n  warning\n" [Char]
"message\n  error\n"
      (([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error") TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),
    [Char] -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"" () (() -> TrackedErrorsIO ()
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return () TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message"),
    [Char] -> [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"" [Char]
"message\n" (TrackedErrorsIO ()
forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' TrackedErrorsIO Char -> [Char] -> TrackedErrorsIO Char
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message"),
    [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"message\n  error\n" ([Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),
    [Char] -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"warning\n" ()
      ([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),
    [Char] -> [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"warning\n" [Char]
"message\n  error\n"
      (([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error") TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),
    [Char] -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"" () (() -> TrackedErrorsIO ()
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return () TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message"),
    [Char] -> [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"" [Char]
"message\n" (TrackedErrorsIO ()
forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM TrackedErrorsIO () -> [Char] -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),

    [Char] -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"error\n" ()
      (TrackedErrors Any -> TrackedErrorsIO ()
forall (m :: * -> *) a.
Monad m =>
TrackedErrors a -> TrackedErrorsT m ()
asCompilerWarnings (TrackedErrors Any -> TrackedErrorsIO ())
-> TrackedErrors Any -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors Any
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),
    [Char] -> [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"" [Char]
"warning\n"
      (TrackedErrors () -> TrackedErrorsIO ()
forall (m :: * -> *) a.
Monad m =>
TrackedErrors a -> TrackedErrorsT m ()
asCompilerError (TrackedErrors () -> TrackedErrorsIO ())
-> TrackedErrors () -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" :: TrackedErrorsIO ()),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' ([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background" TrackedErrorsIO () -> TrackedErrorsIO Char -> TrackedErrorsIO Char
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n  background\n"
      ([Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),
    [Char] -> TrackedErrorsIO [()] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n  background\n"
      ([TrackedErrorsIO ()] -> TrackedErrorsIO [()]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO [a]
collectAllM [[Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background"] TrackedErrorsIO [()]
-> TrackedErrorsIO [()] -> TrackedErrorsIO [()]
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO [()]
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO [()]),
    [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n  background\n"
      ([TrackedErrorsIO ()] -> TrackedErrorsIO ()
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
forall (f :: * -> *) a.
Foldable f =>
f (TrackedErrorsT IO a) -> TrackedErrorsT IO a
collectFirstM [[Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background"] TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' ((TrackedErrorsIO () -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> m a
resetBackgroundM (TrackedErrorsIO () -> TrackedErrorsIO ())
-> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background") TrackedErrorsIO () -> TrackedErrorsIO Char -> TrackedErrorsIO Char
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> TrackedErrorsIO Char
forall a. a -> TrackedErrorsT IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    [Char] -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n"
      ((TrackedErrorsIO () -> TrackedErrorsIO ()
forall a. TrackedErrorsT IO a -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => m a -> m a
resetBackgroundM (TrackedErrorsIO () -> TrackedErrorsIO ())
-> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background") TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b.
TrackedErrorsT IO a -> TrackedErrorsT IO b -> TrackedErrorsT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsIO ()
forall a. [Char] -> TrackedErrorsT IO a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),

    (Char, [Char])
-> TrackedErrorsT (Writer [Char]) Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
(a, [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterSuccess (Char
'x',[Char]
"ab") (TrackedErrorsT (Writer [Char]) Char
-> Writer [Char] ()
-> Writer [Char] ()
-> TrackedErrorsT (Writer [Char]) Char
forall (m :: * -> *) a.
(Monad m, ErrorContextM (TrackedErrorsT m)) =>
TrackedErrorsT m a -> m () -> m () -> TrackedErrorsT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m () -> m () -> t m a
ifElseSuccessT (Writer [Char] () -> TrackedErrorsT (Writer [Char]) ()
forall (m :: * -> *) a. Monad m => m a -> TrackedErrorsT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift ([Char] -> Writer [Char] ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"a") TrackedErrorsT (Writer [Char]) ()
-> TrackedErrorsT (Writer [Char]) Char
-> TrackedErrorsT (Writer [Char]) Char
forall a b.
TrackedErrorsT (Writer [Char]) a
-> TrackedErrorsT (Writer [Char]) b
-> TrackedErrorsT (Writer [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> TrackedErrorsT (Writer [Char]) Char
forall a. a -> TrackedErrorsT (Writer [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'x') ([Char] -> Writer [Char] ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"b") ([Char] -> Writer [Char] ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"c")),
    ([Char], [Char])
-> TrackedErrorsT (Writer [Char]) () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
([Char], [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterFail ([Char]
"failed\n",[Char]
"ac") (TrackedErrorsT (Writer [Char]) ()
-> Writer [Char] ()
-> Writer [Char] ()
-> TrackedErrorsT (Writer [Char]) ()
forall (m :: * -> *) a.
(Monad m, ErrorContextM (TrackedErrorsT m)) =>
TrackedErrorsT m a -> m () -> m () -> TrackedErrorsT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m () -> m () -> t m a
ifElseSuccessT (Writer [Char] () -> TrackedErrorsT (Writer [Char]) ()
forall (m :: * -> *) a. Monad m => m a -> TrackedErrorsT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift ([Char] -> Writer [Char] ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"a") TrackedErrorsT (Writer [Char]) ()
-> TrackedErrorsT (Writer [Char]) ()
-> TrackedErrorsT (Writer [Char]) ()
forall a b.
TrackedErrorsT (Writer [Char]) a
-> TrackedErrorsT (Writer [Char]) b
-> TrackedErrorsT (Writer [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> TrackedErrorsT (Writer [Char]) ()
forall a. [Char] -> TrackedErrorsT (Writer [Char]) a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"failed") ([Char] -> Writer [Char] ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"b") ([Char] -> Writer [Char] ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"c") :: TrackedErrorsT (Writer String) ())
  ]

checkWriterSuccess :: (Eq a, Show a) => (a,String) -> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterSuccess :: forall a.
(Eq a, Show a) =>
(a, [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterSuccess (a, [Char])
x TrackedErrorsT (Writer [Char]) a
y = do
  let (Bool
failed,[Char]
_) = Writer [Char] Bool -> (Bool, [Char])
forall w a. Writer w a -> (a, w)
runWriter (Writer [Char] Bool -> (Bool, [Char]))
-> Writer [Char] Bool -> (Bool, [Char])
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a -> Writer [Char] Bool
forall (m :: * -> *) a.
(Monad m, ErrorContextM (TrackedErrorsT m)) =>
TrackedErrorsT m a -> m Bool
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m Bool
isCompilerErrorT TrackedErrorsT (Writer [Char]) a
y
  if Bool
failed
     then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ (TrackedErrors (), [Char]) -> TrackedErrors ()
forall a b. (a, b) -> a
fst ((TrackedErrors (), [Char]) -> TrackedErrors ())
-> (TrackedErrors (), [Char]) -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ Writer [Char] (TrackedErrors ()) -> (TrackedErrors (), [Char])
forall w a. Writer w a -> (a, w)
runWriter (Writer [Char] (TrackedErrors ()) -> (TrackedErrors (), [Char]))
-> Writer [Char] (TrackedErrors ()) -> (TrackedErrors (), [Char])
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) ()
-> Writer [Char] (TrackedErrors ())
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors (TrackedErrorsT (Writer [Char]) ()
 -> Writer [Char] (TrackedErrors ()))
-> TrackedErrorsT (Writer [Char]) ()
-> Writer [Char] (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a
y TrackedErrorsT (Writer [Char]) a
-> TrackedErrorsT (Writer [Char]) ()
-> TrackedErrorsT (Writer [Char]) ()
forall a b.
TrackedErrorsT (Writer [Char]) a
-> TrackedErrorsT (Writer [Char]) b
-> TrackedErrorsT (Writer [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrorsT (Writer [Char]) ()
forall a. a -> TrackedErrorsT (Writer [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else do
       let y' :: (a, [Char])
y' = Writer [Char] a -> (a, [Char])
forall w a. Writer w a -> (a, w)
runWriter (Writer [Char] a -> (a, [Char])) -> Writer [Char] a -> (a, [Char])
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a -> Writer [Char] a
forall (m :: * -> *) a. Monad m => TrackedErrorsT m a -> m a
getCompilerSuccessT TrackedErrorsT (Writer [Char]) a
y
       if (a, [Char])
y' (a, [Char]) -> (a, [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== (a, [Char])
x
          then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected value " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (a, [Char]) -> [Char]
forall a. Show a => a -> [Char]
show (a, [Char])
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but got value " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (a, [Char]) -> [Char]
forall a. Show a => a -> [Char]
show (a, [Char])
y'

checkWriterFail :: (Eq a, Show a) => (String,String) -> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterFail :: forall a.
(Eq a, Show a) =>
([Char], [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterFail ([Char], [Char])
x TrackedErrorsT (Writer [Char]) a
y = do
  let (Bool
failed,[Char]
_) = Writer [Char] Bool -> (Bool, [Char])
forall w a. Writer w a -> (a, w)
runWriter (Writer [Char] Bool -> (Bool, [Char]))
-> Writer [Char] Bool -> (Bool, [Char])
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a -> Writer [Char] Bool
forall (m :: * -> *) a.
(Monad m, ErrorContextM (TrackedErrorsT m)) =>
TrackedErrorsT m a -> m Bool
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m Bool
isCompilerErrorT TrackedErrorsT (Writer [Char]) a
y
  if Bool
failed
     then do
       let y' :: ([Char], [Char])
y' = (CompilerMessage -> [Char])
-> (CompilerMessage, [Char]) -> ([Char], [Char])
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show ((CompilerMessage, [Char]) -> ([Char], [Char]))
-> (CompilerMessage, [Char]) -> ([Char], [Char])
forall a b. (a -> b) -> a -> b
$ Writer [Char] CompilerMessage -> (CompilerMessage, [Char])
forall w a. Writer w a -> (a, w)
runWriter (Writer [Char] CompilerMessage -> (CompilerMessage, [Char]))
-> Writer [Char] CompilerMessage -> (CompilerMessage, [Char])
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a -> Writer [Char] CompilerMessage
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m CompilerMessage
getCompilerErrorT TrackedErrorsT (Writer [Char]) a
y
       if ([Char], [Char])
y' ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char], [Char])
x
          then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected error " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ([Char], [Char]) -> [Char]
forall a. Show a => a -> [Char]
show ([Char], [Char])
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but got error " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ([Char], [Char]) -> [Char]
forall a. Show a => a -> [Char]
show ([Char], [Char])
y'
     else do
       let y' :: (a, [Char])
y' = Writer [Char] a -> (a, [Char])
forall w a. Writer w a -> (a, w)
runWriter (Writer [Char] a -> (a, [Char])) -> Writer [Char] a -> (a, [Char])
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a -> Writer [Char] a
forall (m :: * -> *) a. Monad m => TrackedErrorsT m a -> m a
getCompilerSuccessT TrackedErrorsT (Writer [Char]) a
y
       TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected failure but got value " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (a, [Char]) -> [Char]
forall a. Show a => a -> [Char]
show (a, [Char])
y'

checkSuccess :: (Eq a, Show a) => a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess :: forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess a
x TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  if TrackedErrors a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrors a
y' Bool -> Bool -> Bool
|| TrackedErrors a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y' a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x
     then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors a
y' TrackedErrors a -> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected value " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show a
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but got value " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y')

checkError :: (Eq a, Show a) => String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError :: forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
e TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  if Bool -> Bool
not (TrackedErrors a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrors a
y')
     then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected error \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\" but got value " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y')
     else if CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrors a
y') [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
e
          then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected error \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\" but got error \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrors a
y') [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\""

checkSuccessAndWarnings :: (Eq a, Show a) => String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings :: forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
w a
x TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  TrackedErrors ()
outcome <- a -> TrackedErrorsIO a -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess a
x TrackedErrorsIO a
y
  if CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
w
     then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors ()
outcome TrackedErrors () -> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected warnings " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
w [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but got warnings \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\""

checkErrorAndWarnings :: (Eq a, Show a) => String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings :: forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
w [Char]
e TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  TrackedErrors ()
outcome <- [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
e TrackedErrorsIO a
y
  if CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
w
     then TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors ()
outcome TrackedErrors () -> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ [Char] -> TrackedErrors ()
forall a. [Char] -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM ([Char] -> TrackedErrors ()) -> [Char] -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected warnings " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
w [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" but got warnings \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> [Char]
forall a. Show a => a -> [Char]
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\""