{- -----------------------------------------------------------------------------
Copyright 2020 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.CompileInfo (tests) where

import Base.CompileError
import Base.CompileInfo


tests :: [IO (CompileInfo ())]
tests :: [IO (CompileInfo ())]
tests = [
    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'a' (Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    String -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"error\n" (String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" :: CompileInfoIO Char),
    String -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"" (String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"" :: CompileInfoIO Char),

    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess [Char
'a',Char
'b']          ([CompileInfoIO Char] -> CompileInfoIO String
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess []                 ([CompileInfoIO Char] -> CompileInfoIO String
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [] :: CompileInfoIO [Char]),
    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError   String
"error1\nerror2\n" ([CompileInfoIO Char] -> CompileInfoIO String
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error1",Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error2"]),

    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess String
"ab" ([CompileInfoIO Char] -> CompileInfoIO String
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess String
""   ([CompileInfoIO Char] -> CompileInfoIO String
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [] :: CompileInfoIO [Char]),
    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess String
"b"  ([CompileInfoIO Char] -> CompileInfoIO String
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error1",Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error2"]),

    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'a' ([CompileInfoIO Char] -> CompileInfoIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m a
collectFirstM [Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError   String
""  ([CompileInfoIO Char] -> CompileInfoIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m a
collectFirstM [] :: CompileInfoIO Char),
    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'b' ([CompileInfoIO Char] -> CompileInfoIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m a
collectFirstM [String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error1",Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error2"]),

    String -> () -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
"warning1\nwarning2\n" ()
      (String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning1" CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> CompileInfoIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return () CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning2"),
    String -> String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
"warning1\n" String
"error\n"
      (String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning1" CompileInfoIO () -> CompileInfoT IO Any -> CompileInfoT IO Any
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoT IO Any
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" CompileInfoT IO Any -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning2" :: CompileInfoIO ()),

    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess [Char
'a',Char
'b']  ([CompileInfoIO Char] -> CompileInfoIO String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess []         ([CompileInfoIO Char] -> CompileInfoIO String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [] :: CompileInfoIO [Char]),
    String -> CompileInfoIO String -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError   String
"error1\n" ([CompileInfoIO Char] -> CompileInfoIO String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error1",Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error2"]),

    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'a' (Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' CompileInfoIO Char -> String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`withContextM` String
"message"),
    String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"message\n  error\n" (String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`withContextM` String
"message" :: CompileInfoIO ()),
    String -> () -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
"message\n  warning\n" ()
      (String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning" CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`withContextM` String
"message" :: CompileInfoIO ()),
    String -> String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
"message\n  warning\n" String
"message\n  error\n"
      ((String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning" CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error") CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`withContextM` String
"message" :: CompileInfoIO ()),
    String -> () -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
"" () (() -> CompileInfoIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return () CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`withContextM` String
"message"),
    String -> String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
"" String
"message\n" (String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"" CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`withContextM` String
"message" :: CompileInfoIO ()),

    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'a' (Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' CompileInfoIO Char -> String -> CompileInfoIO Char
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`summarizeErrorsM` String
"message"),
    String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"message\n  error\n" (String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: CompileInfoIO ()),
    String -> () -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
"warning\n" ()
      (String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning" CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: CompileInfoIO ()),
    String -> String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
"warning\n" String
"message\n  error\n"
      ((String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning" CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error") CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: CompileInfoIO ()),
    String -> () -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
"" () (() -> CompileInfoIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return () CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`summarizeErrorsM` String
"message"),
    String -> String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
"" String
"message\n" (String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"" CompileInfoIO () -> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: CompileInfoIO ()),

    String -> () -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
"error\n" ()
      (CompileInfo Any -> CompileInfoIO ()
forall (m :: * -> *) a.
Monad m =>
CompileInfo a -> CompileInfoT m ()
asCompileWarnings (CompileInfo Any -> CompileInfoIO ())
-> CompileInfo Any -> CompileInfoIO ()
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo Any
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" :: CompileInfoIO ()),
    String -> String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
"" String
"warning\n"
      (CompileInfo () -> CompileInfoIO ()
forall (m :: * -> *) a.
Monad m =>
CompileInfo a -> CompileInfoT m ()
asCompileError (CompileInfo () -> CompileInfoIO ())
-> CompileInfo () -> CompileInfoIO ()
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileWarningM String
"warning" :: CompileInfoIO ()),

    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'a' (String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileBackgroundM String
"background" CompileInfoIO () -> CompileInfoIO Char -> CompileInfoIO Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"error\n  background\n"
      (String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileBackgroundM String
"background" CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" :: CompileInfoIO ()),
    String -> CompileInfoIO [()] -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"error\n  background\n"
      ([CompileInfoIO ()] -> CompileInfoIO [()]
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileBackgroundM String
"background"] CompileInfoIO [()] -> CompileInfoIO [()] -> CompileInfoIO [()]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO [()]
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" :: CompileInfoIO [()]),
    String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"error\n  background\n"
      ([CompileInfoIO ()] -> CompileInfoIO ()
forall (m :: * -> *) (f :: * -> *) a.
(CompileErrorM m, Foldable f) =>
f (m a) -> m a
collectFirstM [String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileBackgroundM String
"background"] CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" :: CompileInfoIO ()),

    Char -> CompileInfoIO Char -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess Char
'a' ((CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> m a
resetBackgroundM (CompileInfoIO () -> CompileInfoIO ())
-> CompileInfoIO () -> CompileInfoIO ()
forall a b. (a -> b) -> a -> b
$ String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileBackgroundM String
"background") CompileInfoIO () -> CompileInfoIO Char -> CompileInfoIO Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> CompileInfoIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    String -> CompileInfoIO () -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
"error\n"
      ((CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => m a -> m a
resetBackgroundM (CompileInfoIO () -> CompileInfoIO ())
-> CompileInfoIO () -> CompileInfoIO ()
forall a b. (a -> b) -> a -> b
$ String -> CompileInfoIO ()
forall (m :: * -> *). CompileErrorM m => String -> m ()
compileBackgroundM String
"background") CompileInfoIO () -> CompileInfoIO () -> CompileInfoIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> CompileInfoIO ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM String
"error" :: CompileInfoIO ())
  ]

checkSuccess :: (Eq a, Show a) => a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess :: a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess a
x CompileInfoIO a
y = do
  CompileInfo a
y' <- CompileInfoIO a -> IO (CompileInfo a)
forall (m :: * -> *) a.
Monad m =>
CompileInfoT m a -> m (CompileInfo a)
toCompileInfo CompileInfoIO a
y
  if CompileInfo a -> Bool
forall a. CompileInfo a -> Bool
isCompileError CompileInfo a
y' Bool -> Bool -> Bool
|| CompileInfo a -> a
forall a. CompileInfo a -> a
getCompileSuccess CompileInfo a
y' a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x
     then CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ CompileInfo a
y' CompileInfo a -> CompileInfo () -> CompileInfo ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> CompileInfo ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (String -> CompileInfo ()) -> String -> CompileInfo ()
forall a b. (a -> b) -> a -> b
$ String
"Expected value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show (CompileInfo a -> a
forall a. CompileInfo a -> a
getCompileSuccess CompileInfo a
y')

checkError :: (Eq a, Show a) => String -> CompileInfoIO a -> IO (CompileInfo ())
checkError :: String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
e CompileInfoIO a
y = do
  CompileInfo a
y' <- CompileInfoIO a -> IO (CompileInfo a)
forall (m :: * -> *) a.
Monad m =>
CompileInfoT m a -> m (CompileInfo a)
toCompileInfo CompileInfoIO a
y
  if Bool -> Bool
not (CompileInfo a -> Bool
forall a. CompileInfo a -> Bool
isCompileError CompileInfo a
y')
     then CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (String -> CompileInfo ()) -> String -> CompileInfo ()
forall a b. (a -> b) -> a -> b
$ String
"Expected error \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\" but got value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show (CompileInfo a -> a
forall a. CompileInfo a -> a
getCompileSuccess CompileInfo a
y')
     else if CompileMessage -> String
forall a. Show a => a -> String
show (CompileInfo a -> CompileMessage
forall a. CompileInfo a -> CompileMessage
getCompileError CompileInfo a
y') String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
e
          then CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ () -> CompileInfo ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (String -> CompileInfo ()) -> String -> CompileInfo ()
forall a b. (a -> b) -> a -> b
$ String
"Expected error \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\" but got error \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompileMessage -> String
forall a. Show a => a -> String
show (CompileInfo a -> CompileMessage
forall a. CompileInfo a -> CompileMessage
getCompileError CompileInfo a
y') String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\""

checkSuccessAndWarnings :: (Eq a, Show a) => String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings :: String -> a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccessAndWarnings String
w a
x CompileInfoIO a
y = do
  CompileInfo a
y' <- CompileInfoIO a -> IO (CompileInfo a)
forall (m :: * -> *) a.
Monad m =>
CompileInfoT m a -> m (CompileInfo a)
toCompileInfo CompileInfoIO a
y
  CompileInfo ()
outcome <- a -> CompileInfoIO a -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
a -> CompileInfoIO a -> IO (CompileInfo ())
checkSuccess a
x CompileInfoIO a
y
  if CompileMessage -> String
forall a. Show a => a -> String
show (CompileInfo a -> CompileMessage
forall a. CompileInfo a -> CompileMessage
getCompileWarnings CompileInfo a
y') String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
w
     then CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ CompileInfo ()
outcome CompileInfo () -> CompileInfo () -> CompileInfo ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> CompileInfo ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (String -> CompileInfo ()) -> String -> CompileInfo ()
forall a b. (a -> b) -> a -> b
$ String
"Expected warnings " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
w String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got warnings \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompileMessage -> String
forall a. Show a => a -> String
show (CompileInfo a -> CompileMessage
forall a. CompileInfo a -> CompileMessage
getCompileWarnings CompileInfo a
y') String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\""

checkErrorAndWarnings :: (Eq a, Show a) => String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings :: String -> String -> CompileInfoIO a -> IO (CompileInfo ())
checkErrorAndWarnings String
w String
e CompileInfoIO a
y = do
  CompileInfo a
y' <- CompileInfoIO a -> IO (CompileInfo a)
forall (m :: * -> *) a.
Monad m =>
CompileInfoT m a -> m (CompileInfo a)
toCompileInfo CompileInfoIO a
y
  CompileInfo ()
outcome <- String -> CompileInfoIO a -> IO (CompileInfo ())
forall a.
(Eq a, Show a) =>
String -> CompileInfoIO a -> IO (CompileInfo ())
checkError String
e CompileInfoIO a
y
  if CompileMessage -> String
forall a. Show a => a -> String
show (CompileInfo a -> CompileMessage
forall a. CompileInfo a -> CompileMessage
getCompileWarnings CompileInfo a
y') String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
w
     then CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ CompileInfo ()
outcome CompileInfo () -> CompileInfo () -> CompileInfo ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> CompileInfo ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else CompileInfo () -> IO (CompileInfo ())
forall (m :: * -> *) a. Monad m => a -> m a
return (CompileInfo () -> IO (CompileInfo ()))
-> CompileInfo () -> IO (CompileInfo ())
forall a b. (a -> b) -> a -> b
$ String -> CompileInfo ()
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (String -> CompileInfo ()) -> String -> CompileInfo ()
forall a b. (a -> b) -> a -> b
$ String
"Expected warnings " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
w String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got warnings \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompileMessage -> String
forall a. Show a => a -> String
show (CompileInfo a -> CompileMessage
forall a. CompileInfo a -> CompileMessage
getCompileWarnings CompileInfo a
y') String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\""