{-# language CPP                    #-}
{-# language DeriveFoldable         #-}
{-# language DeriveFunctor          #-}
{-# language DeriveTraversable      #-}
{-# language FlexibleContexts       #-}
{-# language FlexibleInstances      #-}
{-# language FunctionalDependencies #-}
{-# language MultiParamTypeClasses  #-}
{-# language Rank2Types             #-}
{-# language TemplateHaskell        #-}
{-# language UndecidableInstances   #-}
-----------------------------------------------------------------------------
-- |
-- Copyright   :  (c) Edward Kmett 2011-2019
-- License     :  BSD3
--
-- Maintainer  :  ekmett@gmail.com
-- Stability   :  experimental
-- Portability :  non-portable
--
-- Results and Parse Errors
-----------------------------------------------------------------------------
module Text.Trifecta.Result
  (
  -- * Parse Results
    Result(..)
  , AsResult(..)
  , foldResult
  , _Success
  , _Failure
  -- * Parsing Errors
  , Err(..), HasErr(..), Errable(..)
  , ErrInfo(..)
  , explain
  , failed
  ) where

import           Control.Applicative                          as Alternative
import           Control.Lens                                 hiding (cons, snoc)
import           Control.Monad                                (guard)
import           Data.Foldable
import qualified Data.List                                    as List
import           Data.Maybe                                   (fromMaybe, isJust)
#if !(MIN_VERSION_base(4,11,0))
import           Data.Semigroup
#endif
import           Data.Set                                     as Set hiding (empty, toList)
import           Prettyprinter                                as Pretty
import           Prettyprinter.Render.Terminal                as Pretty

import Text.Trifecta.Delta       as Delta
import Text.Trifecta.Rendering
import Text.Trifecta.Util.Pretty as Pretty

data ErrInfo = ErrInfo
  { ErrInfo -> Doc AnsiStyle
_errDoc    :: Doc AnsiStyle
  , ErrInfo -> [Delta]
_errDeltas :: [Delta]
  } deriving (Int -> ErrInfo -> ShowS
[ErrInfo] -> ShowS
ErrInfo -> String
(Int -> ErrInfo -> ShowS)
-> (ErrInfo -> String) -> ([ErrInfo] -> ShowS) -> Show ErrInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ErrInfo -> ShowS
showsPrec :: Int -> ErrInfo -> ShowS
$cshow :: ErrInfo -> String
show :: ErrInfo -> String
$cshowList :: [ErrInfo] -> ShowS
showList :: [ErrInfo] -> ShowS
Show)

-- | This is used to report an error. What went wrong, some supplemental docs
-- and a set of things expected at the current location. This does not, however,
-- include the actual location.
data Err = Err
  { Err -> Maybe (Doc AnsiStyle)
_reason      :: Maybe (Doc AnsiStyle)
  , Err -> [Doc AnsiStyle]
_footnotes   :: [Doc AnsiStyle]
  , Err -> Set String
_expected    :: Set String
  , Err -> [Delta]
_finalDeltas :: [Delta]
  }

makeClassy ''Err

instance Semigroup Err where
  Err Maybe (Doc AnsiStyle)
md [Doc AnsiStyle]
mds Set String
mes [Delta]
delta1 <> :: Err -> Err -> Err
<> Err Maybe (Doc AnsiStyle)
nd [Doc AnsiStyle]
nds Set String
nes [Delta]
delta2
    = Maybe (Doc AnsiStyle)
-> [Doc AnsiStyle] -> Set String -> [Delta] -> Err
Err (Maybe (Doc AnsiStyle)
nd Maybe (Doc AnsiStyle)
-> Maybe (Doc AnsiStyle) -> Maybe (Doc AnsiStyle)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe (Doc AnsiStyle)
md) (if Maybe (Doc AnsiStyle) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Doc AnsiStyle)
nd then [Doc AnsiStyle]
nds else if Maybe (Doc AnsiStyle) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Doc AnsiStyle)
md then [Doc AnsiStyle]
mds else [Doc AnsiStyle]
nds [Doc AnsiStyle] -> [Doc AnsiStyle] -> [Doc AnsiStyle]
forall a. [a] -> [a] -> [a]
++ [Doc AnsiStyle]
mds) (Set String
mes Set String -> Set String -> Set String
forall a. Semigroup a => a -> a -> a
<> Set String
nes) ([Delta]
delta1 [Delta] -> [Delta] -> [Delta]
forall a. Semigroup a => a -> a -> a
<> [Delta]
delta2)
  {-# inlinable (<>) #-}

instance Monoid Err where
  mempty :: Err
mempty = Maybe (Doc AnsiStyle)
-> [Doc AnsiStyle] -> Set String -> [Delta] -> Err
Err Maybe (Doc AnsiStyle)
forall a. Maybe a
Nothing [] Set String
forall a. Monoid a => a
mempty [Delta]
forall a. Monoid a => a
mempty
  {-# inlinable mempty #-}
  mappend :: Err -> Err -> Err
mappend = Err -> Err -> Err
forall a. Semigroup a => a -> a -> a
(<>)
  {-# inlinable mappend #-}

-- | Generate a simple 'Err' word-wrapping the supplied message.
failed :: String -> Err
failed :: String -> Err
failed String
m = Maybe (Doc AnsiStyle)
-> [Doc AnsiStyle] -> Set String -> [Delta] -> Err
Err (Doc AnsiStyle -> Maybe (Doc AnsiStyle)
forall a. a -> Maybe a
Just ([Doc AnsiStyle] -> Doc AnsiStyle
forall ann. [Doc ann] -> Doc ann
fillSep (String -> Doc AnsiStyle
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc AnsiStyle) -> [String] -> [Doc AnsiStyle]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> [String]
words String
m))) [] Set String
forall a. Monoid a => a
mempty [Delta]
forall a. Monoid a => a
mempty
{-# inlinable failed #-}

-- | Convert a 'Rendering' of auxiliary information and an 'Err' into a 'Doc AnsiStyle',
-- ready to be prettyprinted to the user.
explain :: Rendering -> Err -> Doc AnsiStyle
explain :: Rendering -> Err -> Doc AnsiStyle
explain Rendering
r (Err Maybe (Doc AnsiStyle)
mm [Doc AnsiStyle]
as Set String
es [Delta]
_)
  | Set String -> Bool
forall a. Set a -> Bool
Set.null Set String
es = Doc AnsiStyle -> Doc AnsiStyle
report (Doc AnsiStyle -> Doc AnsiStyle
withEx Doc AnsiStyle
forall a. Monoid a => a
mempty)
  | Maybe (Doc AnsiStyle) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Doc AnsiStyle)
mm   = Doc AnsiStyle -> Doc AnsiStyle
report (Doc AnsiStyle -> Doc AnsiStyle) -> Doc AnsiStyle -> Doc AnsiStyle
forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle -> Doc AnsiStyle
withEx (Doc AnsiStyle -> Doc AnsiStyle) -> Doc AnsiStyle -> Doc AnsiStyle
forall a b. (a -> b) -> a -> b
$ Char -> Doc AnsiStyle
forall a. Char -> Doc a
Pretty.char Char
',' Doc AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc AnsiStyle
forall {ann}. Doc ann
expecting
  | Bool
otherwise   = Doc AnsiStyle -> Doc AnsiStyle
report Doc AnsiStyle
forall {ann}. Doc ann
expecting
  where
    now :: [String]
now = [String] -> [String]
spaceHack ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ Set String -> [String]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set String
es
    spaceHack :: [String] -> [String]
spaceHack [String
""] = [String
"space"]
    spaceHack [String]
xs = (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
List.filter (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"") [String]
xs
    withEx :: Doc AnsiStyle -> Doc AnsiStyle
withEx Doc AnsiStyle
x = Doc AnsiStyle -> Maybe (Doc AnsiStyle) -> Doc AnsiStyle
forall a. a -> Maybe a -> a
fromMaybe ([Doc AnsiStyle] -> Doc AnsiStyle
forall ann. [Doc ann] -> Doc ann
fillSep ([Doc AnsiStyle] -> Doc AnsiStyle)
-> [Doc AnsiStyle] -> Doc AnsiStyle
forall a b. (a -> b) -> a -> b
$ String -> Doc AnsiStyle
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc AnsiStyle) -> [String] -> [Doc AnsiStyle]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> [String]
words String
"unspecified error") Maybe (Doc AnsiStyle)
mm Doc AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall a. Semigroup a => a -> a -> a
<> Doc AnsiStyle
x
    expecting :: Doc ann
expecting = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"expected:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
fillSep (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate (Char -> Doc ann
forall a. Char -> Doc a
Pretty.char Char
',') (String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> [String] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String]
now))
    report :: Doc AnsiStyle -> Doc AnsiStyle
report Doc AnsiStyle
txt = [Doc AnsiStyle] -> Doc AnsiStyle
forall ann. [Doc ann] -> Doc ann
vsep ([Doc AnsiStyle] -> Doc AnsiStyle)
-> [Doc AnsiStyle] -> Doc AnsiStyle
forall a b. (a -> b) -> a -> b
$ [Delta -> Doc AnsiStyle
prettyDelta (Rendering -> Delta
forall t. HasDelta t => t -> Delta
delta Rendering
r) Doc AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall a. Semigroup a => a -> a -> a
<> Char -> Doc AnsiStyle
forall a. Char -> Doc a
Pretty.char Char
':' Doc AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall ann. Doc ann -> Doc ann -> Doc ann
<+> AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall ann. ann -> Doc ann -> Doc ann
annotate (Color -> AnsiStyle
Pretty.color Color
Pretty.Red) (String -> Doc AnsiStyle
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"error") Doc AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall a. Semigroup a => a -> a -> a
<> Char -> Doc AnsiStyle
forall a. Char -> Doc a
Pretty.char Char
':' Doc AnsiStyle -> Doc AnsiStyle -> Doc AnsiStyle
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Int -> Doc AnsiStyle -> Doc AnsiStyle
forall ann. Int -> Doc ann -> Doc ann
nest Int
4 Doc AnsiStyle
txt]
             [Doc AnsiStyle] -> [Doc AnsiStyle] -> [Doc AnsiStyle]
forall a. [a] -> [a] -> [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Rendering -> Doc AnsiStyle
prettyRendering Rendering
r Doc AnsiStyle -> [()] -> [Doc AnsiStyle]
forall a b. a -> [b] -> [a]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Rendering -> Bool
nullRendering Rendering
r))
             [Doc AnsiStyle] -> [Doc AnsiStyle] -> [Doc AnsiStyle]
forall a. [a] -> [a] -> [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Doc AnsiStyle]
as

class Errable m where
  raiseErr :: Err -> m a

instance Monoid ErrInfo where
  mempty :: ErrInfo
mempty = Doc AnsiStyle -> [Delta] -> ErrInfo
ErrInfo Doc AnsiStyle
forall a. Monoid a => a
mempty [Delta]
forall a. Monoid a => a
mempty
  mappend :: ErrInfo -> ErrInfo -> ErrInfo
mappend = ErrInfo -> ErrInfo -> ErrInfo
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ErrInfo where
  ErrInfo Doc AnsiStyle
xs [Delta]
d1 <> :: ErrInfo -> ErrInfo -> ErrInfo
<> ErrInfo Doc AnsiStyle
ys [Delta]
d2 = Doc AnsiStyle -> [Delta] -> ErrInfo
ErrInfo ([Doc AnsiStyle] -> Doc AnsiStyle
forall ann. [Doc ann] -> Doc ann
vsep [Doc AnsiStyle
xs, Doc AnsiStyle
ys]) ([Delta] -> [Delta] -> [Delta]
forall a. Ord a => a -> a -> a
max [Delta]
d1 [Delta]
d2)

-- | The result of parsing. Either we succeeded or something went wrong.
data Result a
  = Success a
  | Failure ErrInfo
  deriving (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
$cshowsPrec :: forall a. Show a => Int -> Result a -> ShowS
showsPrec :: Int -> Result a -> ShowS
$cshow :: forall a. Show a => Result a -> String
show :: Result a -> String
$cshowList :: forall a. Show a => [Result a] -> ShowS
showList :: [Result a] -> ShowS
Show,(forall a b. (a -> b) -> Result a -> Result b)
-> (forall a b. a -> Result b -> Result a) -> Functor Result
forall a b. a -> Result b -> Result a
forall a b. (a -> b) -> Result a -> Result b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Result a -> Result b
fmap :: forall a b. (a -> b) -> Result a -> Result b
$c<$ :: forall a b. a -> Result b -> Result a
<$ :: forall a b. a -> Result b -> Result a
Functor,(forall m. Monoid m => Result m -> m)
-> (forall m a. Monoid m => (a -> m) -> Result a -> m)
-> (forall m a. Monoid m => (a -> m) -> Result a -> m)
-> (forall a b. (a -> b -> b) -> b -> Result a -> b)
-> (forall a b. (a -> b -> b) -> b -> Result a -> b)
-> (forall b a. (b -> a -> b) -> b -> Result a -> b)
-> (forall b a. (b -> a -> b) -> b -> Result a -> b)
-> (forall a. (a -> a -> a) -> Result a -> a)
-> (forall a. (a -> a -> a) -> Result a -> a)
-> (forall a. Result a -> [a])
-> (forall a. Result a -> Bool)
-> (forall a. Result a -> Int)
-> (forall a. Eq a => a -> Result a -> Bool)
-> (forall a. Ord a => Result a -> a)
-> (forall a. Ord a => Result a -> a)
-> (forall a. Num a => Result a -> a)
-> (forall a. Num a => Result a -> a)
-> Foldable Result
forall a. Eq a => a -> Result a -> Bool
forall a. Num a => Result a -> a
forall a. Ord a => Result a -> a
forall m. Monoid m => Result m -> m
forall a. Result a -> Bool
forall a. Result a -> Int
forall a. Result a -> [a]
forall a. (a -> a -> a) -> Result a -> a
forall m a. Monoid m => (a -> m) -> Result a -> m
forall b a. (b -> a -> b) -> b -> Result a -> b
forall a b. (a -> b -> b) -> b -> Result a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Result m -> m
fold :: forall m. Monoid m => Result m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Result a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Result a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Result a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Result a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Result a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Result a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Result a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Result a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Result a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Result a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Result a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Result a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Result a -> a
foldr1 :: forall a. (a -> a -> a) -> Result a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Result a -> a
foldl1 :: forall a. (a -> a -> a) -> Result a -> a
$ctoList :: forall a. Result a -> [a]
toList :: forall a. Result a -> [a]
$cnull :: forall a. Result a -> Bool
null :: forall a. Result a -> Bool
$clength :: forall a. Result a -> Int
length :: forall a. Result a -> Int
$celem :: forall a. Eq a => a -> Result a -> Bool
elem :: forall a. Eq a => a -> Result a -> Bool
$cmaximum :: forall a. Ord a => Result a -> a
maximum :: forall a. Ord a => Result a -> a
$cminimum :: forall a. Ord a => Result a -> a
minimum :: forall a. Ord a => Result a -> a
$csum :: forall a. Num a => Result a -> a
sum :: forall a. Num a => Result a -> a
$cproduct :: forall a. Num a => Result a -> a
product :: forall a. Num a => Result a -> a
Foldable,Functor Result
Foldable Result
(Functor Result, Foldable Result) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Result a -> f (Result b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Result (f a) -> f (Result a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Result a -> m (Result b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Result (m a) -> m (Result a))
-> Traversable Result
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Result (m a) -> m (Result a)
forall (f :: * -> *) a.
Applicative f =>
Result (f a) -> f (Result a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Result a -> m (Result b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Result a -> f (Result b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Result a -> f (Result b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Result a -> f (Result b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Result (f a) -> f (Result a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Result (f a) -> f (Result a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Result a -> m (Result b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Result a -> m (Result b)
$csequence :: forall (m :: * -> *) a. Monad m => Result (m a) -> m (Result a)
sequence :: forall (m :: * -> *) a. Monad m => Result (m a) -> m (Result a)
Traversable)

-- | Fold over a 'Result'
foldResult :: (ErrInfo -> b) -> (a -> b) -> Result a -> b
foldResult :: forall b a. (ErrInfo -> b) -> (a -> b) -> Result a -> b
foldResult ErrInfo -> b
f a -> b
g Result a
r = case Result a
r of
  Failure ErrInfo
e -> ErrInfo -> b
f ErrInfo
e
  Success a
a -> a -> b
g a
a

-- | A 'Prism' that lets you embed or retrieve a 'Result' in a potentially larger type.
class AsResult s t a b | s -> a, t -> b, s b -> t, t a -> s where
  _Result :: Prism s t (Result a) (Result b)

instance AsResult (Result a) (Result b) a b where
  _Result :: Prism (Result a) (Result b) (Result a) (Result b)
_Result = p (Result a) (f (Result b)) -> p (Result a) (f (Result b))
forall a. a -> a
id
  {-# inlinable _Result #-}

-- | The 'Prism' for the 'Success' constructor of 'Result'
_Success :: AsResult s t a b => Prism s t a b
_Success :: forall s t a b. AsResult s t a b => Prism s t a b
_Success = p (Result a) (f (Result b)) -> p s (f t)
forall s t a b. AsResult s t a b => Prism s t (Result a) (Result b)
Prism s t (Result a) (Result b)
_Result (p (Result a) (f (Result b)) -> p s (f t))
-> (p a (f b) -> p (Result a) (f (Result b)))
-> p a (f b)
-> p s (f t)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Result a -> Either (f (Result b)) a)
-> (Either (f (Result b)) (f (Result b)) -> f (Result b))
-> p (Either (f (Result b)) a)
     (Either (f (Result b)) (f (Result b)))
-> p (Result a) (f (Result b))
forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap Result a -> Either (f (Result b)) a
forall {f :: * -> *} {b} {a}.
Applicative f =>
Result b -> Either (f (Result a)) b
seta ((f (Result b) -> f (Result b))
-> (f (Result b) -> f (Result b))
-> Either (f (Result b)) (f (Result b))
-> f (Result b)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either f (Result b) -> f (Result b)
forall a. a -> a
id f (Result b) -> f (Result b)
forall a. a -> a
id) (p (Either (f (Result b)) a) (Either (f (Result b)) (f (Result b)))
 -> p (Result a) (f (Result b)))
-> (p a (f b)
    -> p (Either (f (Result b)) a)
         (Either (f (Result b)) (f (Result b))))
-> p a (f b)
-> p (Result a) (f (Result b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p a (f (Result b))
-> p (Either (f (Result b)) a)
     (Either (f (Result b)) (f (Result b)))
forall a b c. p a b -> p (Either c a) (Either c b)
forall (p :: * -> * -> *) a b c.
Choice p =>
p a b -> p (Either c a) (Either c b)
right' (p a (f (Result b))
 -> p (Either (f (Result b)) a)
      (Either (f (Result b)) (f (Result b))))
-> (p a (f b) -> p a (f (Result b)))
-> p a (f b)
-> p (Either (f (Result b)) a)
     (Either (f (Result b)) (f (Result b)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f b -> f (Result b)) -> p a (f b) -> p a (f (Result b))
forall b c a. (b -> c) -> p a b -> p a c
forall (p :: * -> * -> *) b c a.
Profunctor p =>
(b -> c) -> p a b -> p a c
rmap ((b -> Result b) -> f b -> f (Result b)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> Result b
forall a. a -> Result a
Success) where
  seta :: Result b -> Either (f (Result a)) b
seta (Success b
a) = b -> Either (f (Result a)) b
forall a b. b -> Either a b
Right b
a
  seta (Failure ErrInfo
e) = f (Result a) -> Either (f (Result a)) b
forall a b. a -> Either a b
Left (Result a -> f (Result a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ErrInfo -> Result a
forall a. ErrInfo -> Result a
Failure ErrInfo
e))
{-# inlinable _Success #-}

-- | The 'Prism' for the 'Failure' constructor of 'Result'
_Failure :: AsResult s s a a => Prism' s ErrInfo
_Failure :: forall s a. AsResult s s a a => Prism' s ErrInfo
_Failure = p (Result a) (f (Result a)) -> p s (f s)
forall s t a b. AsResult s t a b => Prism s t (Result a) (Result b)
Prism s s (Result a) (Result a)
_Result (p (Result a) (f (Result a)) -> p s (f s))
-> (p ErrInfo (f ErrInfo) -> p (Result a) (f (Result a)))
-> p ErrInfo (f ErrInfo)
-> p s (f s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Result a -> Either (f (Result a)) ErrInfo)
-> (Either (f (Result a)) (f (Result a)) -> f (Result a))
-> p (Either (f (Result a)) ErrInfo)
     (Either (f (Result a)) (f (Result a)))
-> p (Result a) (f (Result a))
forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap Result a -> Either (f (Result a)) ErrInfo
forall {f :: * -> *} {a}.
Applicative f =>
Result a -> Either (f (Result a)) ErrInfo
seta ((f (Result a) -> f (Result a))
-> (f (Result a) -> f (Result a))
-> Either (f (Result a)) (f (Result a))
-> f (Result a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either f (Result a) -> f (Result a)
forall a. a -> a
id f (Result a) -> f (Result a)
forall a. a -> a
id) (p (Either (f (Result a)) ErrInfo)
   (Either (f (Result a)) (f (Result a)))
 -> p (Result a) (f (Result a)))
-> (p ErrInfo (f ErrInfo)
    -> p (Either (f (Result a)) ErrInfo)
         (Either (f (Result a)) (f (Result a))))
-> p ErrInfo (f ErrInfo)
-> p (Result a) (f (Result a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p ErrInfo (f (Result a))
-> p (Either (f (Result a)) ErrInfo)
     (Either (f (Result a)) (f (Result a)))
forall a b c. p a b -> p (Either c a) (Either c b)
forall (p :: * -> * -> *) a b c.
Choice p =>
p a b -> p (Either c a) (Either c b)
right' (p ErrInfo (f (Result a))
 -> p (Either (f (Result a)) ErrInfo)
      (Either (f (Result a)) (f (Result a))))
-> (p ErrInfo (f ErrInfo) -> p ErrInfo (f (Result a)))
-> p ErrInfo (f ErrInfo)
-> p (Either (f (Result a)) ErrInfo)
     (Either (f (Result a)) (f (Result a)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f ErrInfo -> f (Result a))
-> p ErrInfo (f ErrInfo) -> p ErrInfo (f (Result a))
forall b c a. (b -> c) -> p a b -> p a c
forall (p :: * -> * -> *) b c a.
Profunctor p =>
(b -> c) -> p a b -> p a c
rmap ((ErrInfo -> Result a) -> f ErrInfo -> f (Result a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ErrInfo -> Result a
forall a. ErrInfo -> Result a
Failure) where
  seta :: Result a -> Either (f (Result a)) ErrInfo
seta (Failure ErrInfo
e) = ErrInfo -> Either (f (Result a)) ErrInfo
forall a b. b -> Either a b
Right ErrInfo
e
  seta (Success a
a) = f (Result a) -> Either (f (Result a)) ErrInfo
forall a b. a -> Either a b
Left (Result a -> f (Result a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Result a
forall a. a -> Result a
Success a
a))
{-# inlinable _Failure #-}

instance Applicative Result where
  pure :: forall a. a -> Result a
pure = a -> Result a
forall a. a -> Result a
Success
  {-# inlinable pure #-}
  Success a -> b
f <*> :: forall a b. Result (a -> b) -> Result a -> Result b
<*> Success a
a = b -> Result b
forall a. a -> Result a
Success (a -> b
f a
a)
  Success a -> b
_ <*> Failure ErrInfo
y = ErrInfo -> Result b
forall a. ErrInfo -> Result a
Failure ErrInfo
y
  Failure ErrInfo
x <*> Success a
_ = ErrInfo -> Result b
forall a. ErrInfo -> Result a
Failure ErrInfo
x
  Failure ErrInfo
x <*> Failure ErrInfo
y =
    ErrInfo -> Result b
forall a. ErrInfo -> Result a
Failure (ErrInfo -> Result b) -> ErrInfo -> Result b
forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle -> [Delta] -> ErrInfo
ErrInfo ([Doc AnsiStyle] -> Doc AnsiStyle
forall ann. [Doc ann] -> Doc ann
vsep [ErrInfo -> Doc AnsiStyle
_errDoc ErrInfo
x, ErrInfo -> Doc AnsiStyle
_errDoc ErrInfo
y]) (ErrInfo -> [Delta]
_errDeltas ErrInfo
x [Delta] -> [Delta] -> [Delta]
forall a. Semigroup a => a -> a -> a
<> ErrInfo -> [Delta]
_errDeltas ErrInfo
y)
  {-# inlinable (<*>) #-}

instance Alternative Result where
  Failure ErrInfo
x <|> :: forall a. Result a -> Result a -> Result a
<|> Failure ErrInfo
y =
    ErrInfo -> Result a
forall a. ErrInfo -> Result a
Failure (ErrInfo -> Result a) -> ErrInfo -> Result a
forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle -> [Delta] -> ErrInfo
ErrInfo ([Doc AnsiStyle] -> Doc AnsiStyle
forall ann. [Doc ann] -> Doc ann
vsep [ErrInfo -> Doc AnsiStyle
_errDoc ErrInfo
x, ErrInfo -> Doc AnsiStyle
_errDoc ErrInfo
y]) (ErrInfo -> [Delta]
_errDeltas ErrInfo
x [Delta] -> [Delta] -> [Delta]
forall a. Semigroup a => a -> a -> a
<> ErrInfo -> [Delta]
_errDeltas ErrInfo
y)
  Success a
a <|> Success a
_ = a -> Result a
forall a. a -> Result a
Success a
a
  Success a
a <|> Failure ErrInfo
_ = a -> Result a
forall a. a -> Result a
Success a
a
  Failure ErrInfo
_ <|> Success a
a = a -> Result a
forall a. a -> Result a
Success a
a
  {-# inlinable (<|>) #-}
  empty :: forall a. Result a
empty = ErrInfo -> Result a
forall a. ErrInfo -> Result a
Failure ErrInfo
forall a. Monoid a => a
mempty
  {-# inlinable empty #-}

instance Monad Result where
  return :: forall a. a -> Result a
return = a -> Result a
forall a. a -> Result a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  Success a
a >>= :: forall a b. Result a -> (a -> Result b) -> Result b
>>= a -> Result b
m = a -> Result b
m a
a
  Failure ErrInfo
e >>= a -> Result b
_ = ErrInfo -> Result b
forall a. ErrInfo -> Result a
Failure ErrInfo
e