{-|
Description : Result with possible errors
-}
module Language.Haskell.Formatter.Result
       (Result, toEither, fatalError, fatalAssertionError) where
import qualified Control.Applicative as Applicative
import qualified Control.Monad as Monad
import qualified Language.Haskell.Formatter.Error as Error

newtype Result a = Result (Either Error.Error a)
                     deriving (Result a -> Result a -> Bool
(Result a -> Result a -> Bool)
-> (Result a -> Result a -> Bool) -> Eq (Result a)
forall a. Eq a => Result a -> Result a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Result a -> Result a -> Bool
$c/= :: forall a. Eq a => Result a -> Result a -> Bool
== :: Result a -> Result a -> Bool
$c== :: forall a. Eq a => Result a -> Result a -> Bool
Eq, Eq (Result a)
Eq (Result a)
-> (Result a -> Result a -> Ordering)
-> (Result a -> Result a -> Bool)
-> (Result a -> Result a -> Bool)
-> (Result a -> Result a -> Bool)
-> (Result a -> Result a -> Bool)
-> (Result a -> Result a -> Result a)
-> (Result a -> Result a -> Result a)
-> Ord (Result a)
Result a -> Result a -> Bool
Result a -> Result a -> Ordering
Result a -> Result a -> Result a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Result a)
forall a. Ord a => Result a -> Result a -> Bool
forall a. Ord a => Result a -> Result a -> Ordering
forall a. Ord a => Result a -> Result a -> Result a
min :: Result a -> Result a -> Result a
$cmin :: forall a. Ord a => Result a -> Result a -> Result a
max :: Result a -> Result a -> Result a
$cmax :: forall a. Ord a => Result a -> Result a -> Result a
>= :: Result a -> Result a -> Bool
$c>= :: forall a. Ord a => Result a -> Result a -> Bool
> :: Result a -> Result a -> Bool
$c> :: forall a. Ord a => Result a -> Result a -> Bool
<= :: Result a -> Result a -> Bool
$c<= :: forall a. Ord a => Result a -> Result a -> Bool
< :: Result a -> Result a -> Bool
$c< :: forall a. Ord a => Result a -> Result a -> Bool
compare :: Result a -> Result a -> Ordering
$ccompare :: forall a. Ord a => Result a -> Result a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Result a)
Ord, Int -> Result a -> ShowS
[Result a] -> ShowS
Result a -> String
(Int -> Result a -> ShowS)
-> (Result a -> String) -> ([Result a] -> ShowS) -> Show (Result a)
forall a. Show a => Int -> Result a -> ShowS
forall a. Show a => [Result a] -> ShowS
forall a. Show a => Result a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Result a] -> ShowS
$cshowList :: forall a. Show a => [Result a] -> ShowS
show :: Result a -> String
$cshow :: forall a. Show a => Result a -> String
showsPrec :: Int -> Result a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Result a -> ShowS
Show)

instance Functor Result where
        fmap :: (a -> b) -> Result a -> Result b
fmap = (a -> b) -> Result a -> Result b
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
Monad.liftM

instance Applicative.Applicative Result where
        pure :: a -> Result a
pure = a -> Result a
forall (m :: * -> *) a. Monad m => a -> m a
return
        <*> :: Result (a -> b) -> Result a -> Result b
(<*>) = Result (a -> b) -> Result a -> Result b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
Monad.ap

instance Monad Result where
        return :: a -> Result a
return = Either Error a -> Result a
forall a. Either Error a -> Result a
Result (Either Error a -> Result a)
-> (a -> Either Error a) -> a -> Result a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either Error a
forall (m :: * -> *) a. Monad m => a -> m a
return
        Result Either Error a
result >>= :: Result a -> (a -> Result b) -> Result b
>>= a -> Result b
action = Either Error b -> Result b
forall a. Either Error a -> Result a
Result (Either Error b -> Result b) -> Either Error b -> Result b
forall a b. (a -> b) -> a -> b
$ Either Error a
result Either Error a -> (a -> Either Error b) -> Either Error b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Result b -> Either Error b
forall a. Result a -> Either Error a
toEither (Result b -> Either Error b)
-> (a -> Result b) -> a -> Either Error b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Result b
action

toEither :: Result a -> Either Error.Error a
toEither :: Result a -> Either Error a
toEither (Result Either Error a
result) = Either Error a
result

fatalError :: Error.Error -> Result a
fatalError :: Error -> Result a
fatalError = Either Error a -> Result a
forall a. Either Error a -> Result a
Result (Either Error a -> Result a)
-> (Error -> Either Error a) -> Error -> Result a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Error -> Either Error a
forall a b. a -> Either a b
Left

fatalAssertionError :: String -> Result a
fatalAssertionError :: String -> Result a
fatalAssertionError = Error -> Result a
forall a. Error -> Result a
fatalError (Error -> Result a) -> (String -> Error) -> String -> Result a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Error
Error.createAssertionError