{-# language CPP                #-}
{-# language DeriveAnyClass     #-}
{-# language KindSignatures     #-}
{-# language PatternSynonyms    #-}
{-# language RankNTypes         #-}
{-# language TemplateHaskell    #-}

-- | The source location annotated nix expression type and supporting types.
--
module Nix.Expr.Types.Annotated
  ( module Nix.Expr.Types.Annotated
  , module Data.Functor.Compose
  , SourcePos(..)
  , unPos
  , mkPos
  )
where

import           Nix.Prelude
import           Codec.Serialise
import           Control.DeepSeq
import           Data.Aeson                     ( ToJSON(..)
                                                , FromJSON(..)
                                                )
import           Data.Aeson.TH
import           Data.Binary                    ( Binary(..) )
import           Data.Data
import           Data.Eq.Deriving
import           Data.Fix                       ( Fix(..)
                                                , unfoldFix
                                                )
import           Data.Functor.Compose
import           Data.Hashable.Lifted
import           Data.Ord.Deriving
import           GHC.Generics
import           Nix.Atoms
import           Nix.Expr.Types
import           Text.Megaparsec                ( unPos
                                                , mkPos
                                                )
import           Text.Megaparsec.Pos            ( SourcePos(..) )
import           Text.Read.Deriving
import           Text.Show.Deriving

-- * data type @SrcSpan@ - a zone in a source file

-- | Demarcation of a chunk in a source file.
data SrcSpan = SrcSpan
  { SrcSpan -> SourcePos
spanBegin :: SourcePos
  , SrcSpan -> SourcePos
spanEnd   :: SourcePos
  }
 deriving (Eq SrcSpan
Eq SrcSpan
-> (SrcSpan -> SrcSpan -> Ordering)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> SrcSpan)
-> (SrcSpan -> SrcSpan -> SrcSpan)
-> Ord SrcSpan
SrcSpan -> SrcSpan -> Bool
SrcSpan -> SrcSpan -> Ordering
SrcSpan -> SrcSpan -> SrcSpan
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
min :: SrcSpan -> SrcSpan -> SrcSpan
$cmin :: SrcSpan -> SrcSpan -> SrcSpan
max :: SrcSpan -> SrcSpan -> SrcSpan
$cmax :: SrcSpan -> SrcSpan -> SrcSpan
>= :: SrcSpan -> SrcSpan -> Bool
$c>= :: SrcSpan -> SrcSpan -> Bool
> :: SrcSpan -> SrcSpan -> Bool
$c> :: SrcSpan -> SrcSpan -> Bool
<= :: SrcSpan -> SrcSpan -> Bool
$c<= :: SrcSpan -> SrcSpan -> Bool
< :: SrcSpan -> SrcSpan -> Bool
$c< :: SrcSpan -> SrcSpan -> Bool
compare :: SrcSpan -> SrcSpan -> Ordering
$ccompare :: SrcSpan -> SrcSpan -> Ordering
$cp1Ord :: Eq SrcSpan
Ord, SrcSpan -> SrcSpan -> Bool
(SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool) -> Eq SrcSpan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SrcSpan -> SrcSpan -> Bool
$c/= :: SrcSpan -> SrcSpan -> Bool
== :: SrcSpan -> SrcSpan -> Bool
$c== :: SrcSpan -> SrcSpan -> Bool
Eq, (forall x. SrcSpan -> Rep SrcSpan x)
-> (forall x. Rep SrcSpan x -> SrcSpan) -> Generic SrcSpan
forall x. Rep SrcSpan x -> SrcSpan
forall x. SrcSpan -> Rep SrcSpan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SrcSpan x -> SrcSpan
$cfrom :: forall x. SrcSpan -> Rep SrcSpan x
Generic, Typeable, Typeable SrcSpan
DataType
Constr
Typeable SrcSpan
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SrcSpan)
-> (SrcSpan -> Constr)
-> (SrcSpan -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SrcSpan))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan))
-> ((forall b. Data b => b -> b) -> SrcSpan -> SrcSpan)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r)
-> (forall u. (forall d. Data d => d -> u) -> SrcSpan -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SrcSpan -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan)
-> Data SrcSpan
SrcSpan -> DataType
SrcSpan -> Constr
(forall b. Data b => b -> b) -> SrcSpan -> SrcSpan
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SrcSpan -> u
forall u. (forall d. Data d => d -> u) -> SrcSpan -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SrcSpan)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)
$cSrcSpan :: Constr
$tSrcSpan :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
gmapMp :: (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
gmapM :: (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SrcSpan -> u
gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SrcSpan -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan
$cgmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SrcSpan)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SrcSpan)
dataTypeOf :: SrcSpan -> DataType
$cdataTypeOf :: SrcSpan -> DataType
toConstr :: SrcSpan -> Constr
$ctoConstr :: SrcSpan -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
$cp1Data :: Typeable SrcSpan
Data, Int -> SrcSpan -> ShowS
[SrcSpan] -> ShowS
SrcSpan -> String
(Int -> SrcSpan -> ShowS)
-> (SrcSpan -> String) -> ([SrcSpan] -> ShowS) -> Show SrcSpan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SrcSpan] -> ShowS
$cshowList :: [SrcSpan] -> ShowS
show :: SrcSpan -> String
$cshow :: SrcSpan -> String
showsPrec :: Int -> SrcSpan -> ShowS
$cshowsPrec :: Int -> SrcSpan -> ShowS
Show, SrcSpan -> ()
(SrcSpan -> ()) -> NFData SrcSpan
forall a. (a -> ()) -> NFData a
rnf :: SrcSpan -> ()
$crnf :: SrcSpan -> ()
NFData, Int -> SrcSpan -> Int
SrcSpan -> Int
(Int -> SrcSpan -> Int) -> (SrcSpan -> Int) -> Hashable SrcSpan
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: SrcSpan -> Int
$chash :: SrcSpan -> Int
hashWithSalt :: Int -> SrcSpan -> Int
$chashWithSalt :: Int -> SrcSpan -> Int
Hashable)

-- ** Instances

instance Semigroup SrcSpan where
  SrcSpan
s1 <> :: SrcSpan -> SrcSpan -> SrcSpan
<> SrcSpan
s2 =
    SourcePos -> SourcePos -> SrcSpan
SrcSpan
      ((SourcePos -> SourcePos -> SourcePos)
-> (SrcSpan -> SourcePos) -> SrcSpan -> SrcSpan -> SourcePos
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on SourcePos -> SourcePos -> SourcePos
forall a. Ord a => a -> a -> a
min SrcSpan -> SourcePos
spanBegin SrcSpan
s1 SrcSpan
s2)
      ((SourcePos -> SourcePos -> SourcePos)
-> (SrcSpan -> SourcePos) -> SrcSpan -> SrcSpan -> SourcePos
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on SourcePos -> SourcePos -> SourcePos
forall a. Ord a => a -> a -> a
max SrcSpan -> SourcePos
spanEnd   SrcSpan
s1 SrcSpan
s2)

instance Binary SrcSpan
instance ToJSON SrcSpan
instance FromJSON SrcSpan

instance Serialise SrcSpan

-- * data type @Ann@

--  2021-08-02: NOTE: Annotation needs to be after what is annotated.
-- | A type constructor applied to a type along with an annotation
--
-- Intended to be used with 'Fix':
-- @type MyType = Fix (Compose (AnnUnit Annotation) F)@
data AnnUnit ann expr = AnnUnit
  { AnnUnit ann expr -> ann
annotation :: ann
  , AnnUnit ann expr -> expr
annotated  :: expr
  }
 deriving
  ( AnnUnit ann expr -> AnnUnit ann expr -> Bool
(AnnUnit ann expr -> AnnUnit ann expr -> Bool)
-> (AnnUnit ann expr -> AnnUnit ann expr -> Bool)
-> Eq (AnnUnit ann expr)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall ann expr.
(Eq ann, Eq expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
/= :: AnnUnit ann expr -> AnnUnit ann expr -> Bool
$c/= :: forall ann expr.
(Eq ann, Eq expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
== :: AnnUnit ann expr -> AnnUnit ann expr -> Bool
$c== :: forall ann expr.
(Eq ann, Eq expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
Eq, Eq (AnnUnit ann expr)
Eq (AnnUnit ann expr)
-> (AnnUnit ann expr -> AnnUnit ann expr -> Ordering)
-> (AnnUnit ann expr -> AnnUnit ann expr -> Bool)
-> (AnnUnit ann expr -> AnnUnit ann expr -> Bool)
-> (AnnUnit ann expr -> AnnUnit ann expr -> Bool)
-> (AnnUnit ann expr -> AnnUnit ann expr -> Bool)
-> (AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr)
-> (AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr)
-> Ord (AnnUnit ann expr)
AnnUnit ann expr -> AnnUnit ann expr -> Bool
AnnUnit ann expr -> AnnUnit ann expr -> Ordering
AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr
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 ann expr. (Ord ann, Ord expr) => Eq (AnnUnit ann expr)
forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Ordering
forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr
min :: AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr
$cmin :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr
max :: AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr
$cmax :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> AnnUnit ann expr
>= :: AnnUnit ann expr -> AnnUnit ann expr -> Bool
$c>= :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
> :: AnnUnit ann expr -> AnnUnit ann expr -> Bool
$c> :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
<= :: AnnUnit ann expr -> AnnUnit ann expr -> Bool
$c<= :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
< :: AnnUnit ann expr -> AnnUnit ann expr -> Bool
$c< :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Bool
compare :: AnnUnit ann expr -> AnnUnit ann expr -> Ordering
$ccompare :: forall ann expr.
(Ord ann, Ord expr) =>
AnnUnit ann expr -> AnnUnit ann expr -> Ordering
$cp1Ord :: forall ann expr. (Ord ann, Ord expr) => Eq (AnnUnit ann expr)
Ord, Typeable (AnnUnit ann expr)
DataType
Constr
Typeable (AnnUnit ann expr)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> AnnUnit ann expr
    -> c (AnnUnit ann expr))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnUnit ann expr))
-> (AnnUnit ann expr -> Constr)
-> (AnnUnit ann expr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnUnit ann expr)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnUnit ann expr)))
-> ((forall b. Data b => b -> b)
    -> AnnUnit ann expr -> AnnUnit ann expr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> AnnUnit ann expr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AnnUnit ann expr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnUnit ann expr -> m (AnnUnit ann expr))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnUnit ann expr -> m (AnnUnit ann expr))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnUnit ann expr -> m (AnnUnit ann expr))
-> Data (AnnUnit ann expr)
AnnUnit ann expr -> DataType
AnnUnit ann expr -> Constr
(forall b. Data b => b -> b)
-> AnnUnit ann expr -> AnnUnit ann expr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnUnit ann expr -> c (AnnUnit ann expr)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AnnUnit ann expr)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AnnUnit ann expr))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> AnnUnit ann expr -> u
forall u. (forall d. Data d => d -> u) -> AnnUnit ann expr -> [u]
forall ann expr.
(Data ann, Data expr) =>
Typeable (AnnUnit ann expr)
forall ann expr.
(Data ann, Data expr) =>
AnnUnit ann expr -> DataType
forall ann expr.
(Data ann, Data expr) =>
AnnUnit ann expr -> Constr
forall ann expr.
(Data ann, Data expr) =>
(forall b. Data b => b -> b)
-> AnnUnit ann expr -> AnnUnit ann expr
forall ann expr u.
(Data ann, Data expr) =>
Int -> (forall d. Data d => d -> u) -> AnnUnit ann expr -> u
forall ann expr u.
(Data ann, Data expr) =>
(forall d. Data d => d -> u) -> AnnUnit ann expr -> [u]
forall ann expr r r'.
(Data ann, Data expr) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
forall ann expr r r'.
(Data ann, Data expr) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
forall ann expr (m :: * -> *).
(Data ann, Data expr, Monad m) =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
forall ann expr (m :: * -> *).
(Data ann, Data expr, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
forall ann expr (c :: * -> *).
(Data ann, Data expr) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AnnUnit ann expr)
forall ann expr (c :: * -> *).
(Data ann, Data expr) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnUnit ann expr -> c (AnnUnit ann expr)
forall ann expr (t :: * -> *) (c :: * -> *).
(Data ann, Data expr, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AnnUnit ann expr))
forall ann expr (t :: * -> * -> *) (c :: * -> *).
(Data ann, Data expr, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AnnUnit ann expr))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AnnUnit ann expr)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnUnit ann expr -> c (AnnUnit ann expr)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AnnUnit ann expr))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AnnUnit ann expr))
$cAnnUnit :: Constr
$tAnnUnit :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
$cgmapMo :: forall ann expr (m :: * -> *).
(Data ann, Data expr, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
gmapMp :: (forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
$cgmapMp :: forall ann expr (m :: * -> *).
(Data ann, Data expr, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
gmapM :: (forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
$cgmapM :: forall ann expr (m :: * -> *).
(Data ann, Data expr, Monad m) =>
(forall d. Data d => d -> m d)
-> AnnUnit ann expr -> m (AnnUnit ann expr)
gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnUnit ann expr -> u
$cgmapQi :: forall ann expr u.
(Data ann, Data expr) =>
Int -> (forall d. Data d => d -> u) -> AnnUnit ann expr -> u
gmapQ :: (forall d. Data d => d -> u) -> AnnUnit ann expr -> [u]
$cgmapQ :: forall ann expr u.
(Data ann, Data expr) =>
(forall d. Data d => d -> u) -> AnnUnit ann expr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
$cgmapQr :: forall ann expr r r'.
(Data ann, Data expr) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
$cgmapQl :: forall ann expr r r'.
(Data ann, Data expr) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnUnit ann expr -> r
gmapT :: (forall b. Data b => b -> b)
-> AnnUnit ann expr -> AnnUnit ann expr
$cgmapT :: forall ann expr.
(Data ann, Data expr) =>
(forall b. Data b => b -> b)
-> AnnUnit ann expr -> AnnUnit ann expr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AnnUnit ann expr))
$cdataCast2 :: forall ann expr (t :: * -> * -> *) (c :: * -> *).
(Data ann, Data expr, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (AnnUnit ann expr))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (AnnUnit ann expr))
$cdataCast1 :: forall ann expr (t :: * -> *) (c :: * -> *).
(Data ann, Data expr, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AnnUnit ann expr))
dataTypeOf :: AnnUnit ann expr -> DataType
$cdataTypeOf :: forall ann expr.
(Data ann, Data expr) =>
AnnUnit ann expr -> DataType
toConstr :: AnnUnit ann expr -> Constr
$ctoConstr :: forall ann expr.
(Data ann, Data expr) =>
AnnUnit ann expr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AnnUnit ann expr)
$cgunfold :: forall ann expr (c :: * -> *).
(Data ann, Data expr) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AnnUnit ann expr)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnUnit ann expr -> c (AnnUnit ann expr)
$cgfoldl :: forall ann expr (c :: * -> *).
(Data ann, Data expr) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnUnit ann expr -> c (AnnUnit ann expr)
$cp1Data :: forall ann expr.
(Data ann, Data expr) =>
Typeable (AnnUnit ann expr)
Data, Typeable, Int -> AnnUnit ann expr -> Int
AnnUnit ann expr -> Int
(Int -> AnnUnit ann expr -> Int)
-> (AnnUnit ann expr -> Int) -> Hashable (AnnUnit ann expr)
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ann expr.
(Hashable ann, Hashable expr) =>
Int -> AnnUnit ann expr -> Int
forall ann expr.
(Hashable ann, Hashable expr) =>
AnnUnit ann expr -> Int
hash :: AnnUnit ann expr -> Int
$chash :: forall ann expr.
(Hashable ann, Hashable expr) =>
AnnUnit ann expr -> Int
hashWithSalt :: Int -> AnnUnit ann expr -> Int
$chashWithSalt :: forall ann expr.
(Hashable ann, Hashable expr) =>
Int -> AnnUnit ann expr -> Int
Hashable
  , (forall x. AnnUnit ann expr -> Rep (AnnUnit ann expr) x)
-> (forall x. Rep (AnnUnit ann expr) x -> AnnUnit ann expr)
-> Generic (AnnUnit ann expr)
forall x. Rep (AnnUnit ann expr) x -> AnnUnit ann expr
forall x. AnnUnit ann expr -> Rep (AnnUnit ann expr) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ann expr x. Rep (AnnUnit ann expr) x -> AnnUnit ann expr
forall ann expr x. AnnUnit ann expr -> Rep (AnnUnit ann expr) x
$cto :: forall ann expr x. Rep (AnnUnit ann expr) x -> AnnUnit ann expr
$cfrom :: forall ann expr x. AnnUnit ann expr -> Rep (AnnUnit ann expr) x
Generic, (forall a. AnnUnit ann a -> Rep1 (AnnUnit ann) a)
-> (forall a. Rep1 (AnnUnit ann) a -> AnnUnit ann a)
-> Generic1 (AnnUnit ann)
forall a. Rep1 (AnnUnit ann) a -> AnnUnit ann a
forall a. AnnUnit ann a -> Rep1 (AnnUnit ann) a
forall ann a. Rep1 (AnnUnit ann) a -> AnnUnit ann a
forall ann a. AnnUnit ann a -> Rep1 (AnnUnit ann) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall ann a. Rep1 (AnnUnit ann) a -> AnnUnit ann a
$cfrom1 :: forall ann a. AnnUnit ann a -> Rep1 (AnnUnit ann) a
Generic1, AnnUnit ann expr -> ()
(AnnUnit ann expr -> ()) -> NFData (AnnUnit ann expr)
forall a. (a -> ()) -> NFData a
forall ann expr.
(NFData ann, NFData expr) =>
AnnUnit ann expr -> ()
rnf :: AnnUnit ann expr -> ()
$crnf :: forall ann expr.
(NFData ann, NFData expr) =>
AnnUnit ann expr -> ()
NFData
  , a -> AnnUnit ann b -> AnnUnit ann a
(a -> b) -> AnnUnit ann a -> AnnUnit ann b
(forall a b. (a -> b) -> AnnUnit ann a -> AnnUnit ann b)
-> (forall a b. a -> AnnUnit ann b -> AnnUnit ann a)
-> Functor (AnnUnit ann)
forall a b. a -> AnnUnit ann b -> AnnUnit ann a
forall a b. (a -> b) -> AnnUnit ann a -> AnnUnit ann b
forall ann a b. a -> AnnUnit ann b -> AnnUnit ann a
forall ann a b. (a -> b) -> AnnUnit ann a -> AnnUnit ann b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AnnUnit ann b -> AnnUnit ann a
$c<$ :: forall ann a b. a -> AnnUnit ann b -> AnnUnit ann a
fmap :: (a -> b) -> AnnUnit ann a -> AnnUnit ann b
$cfmap :: forall ann a b. (a -> b) -> AnnUnit ann a -> AnnUnit ann b
Functor, AnnUnit ann a -> Bool
(a -> m) -> AnnUnit ann a -> m
(a -> b -> b) -> b -> AnnUnit ann a -> b
(forall m. Monoid m => AnnUnit ann m -> m)
-> (forall m a. Monoid m => (a -> m) -> AnnUnit ann a -> m)
-> (forall m a. Monoid m => (a -> m) -> AnnUnit ann a -> m)
-> (forall a b. (a -> b -> b) -> b -> AnnUnit ann a -> b)
-> (forall a b. (a -> b -> b) -> b -> AnnUnit ann a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnnUnit ann a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnnUnit ann a -> b)
-> (forall a. (a -> a -> a) -> AnnUnit ann a -> a)
-> (forall a. (a -> a -> a) -> AnnUnit ann a -> a)
-> (forall a. AnnUnit ann a -> [a])
-> (forall a. AnnUnit ann a -> Bool)
-> (forall a. AnnUnit ann a -> Int)
-> (forall a. Eq a => a -> AnnUnit ann a -> Bool)
-> (forall a. Ord a => AnnUnit ann a -> a)
-> (forall a. Ord a => AnnUnit ann a -> a)
-> (forall a. Num a => AnnUnit ann a -> a)
-> (forall a. Num a => AnnUnit ann a -> a)
-> Foldable (AnnUnit ann)
forall a. Eq a => a -> AnnUnit ann a -> Bool
forall a. Num a => AnnUnit ann a -> a
forall a. Ord a => AnnUnit ann a -> a
forall m. Monoid m => AnnUnit ann m -> m
forall a. AnnUnit ann a -> Bool
forall a. AnnUnit ann a -> Int
forall a. AnnUnit ann a -> [a]
forall a. (a -> a -> a) -> AnnUnit ann a -> a
forall ann a. Eq a => a -> AnnUnit ann a -> Bool
forall ann a. Num a => AnnUnit ann a -> a
forall ann a. Ord a => AnnUnit ann a -> a
forall m a. Monoid m => (a -> m) -> AnnUnit ann a -> m
forall ann m. Monoid m => AnnUnit ann m -> m
forall ann a. AnnUnit ann a -> Bool
forall ann a. AnnUnit ann a -> Int
forall ann a. AnnUnit ann a -> [a]
forall b a. (b -> a -> b) -> b -> AnnUnit ann a -> b
forall a b. (a -> b -> b) -> b -> AnnUnit ann a -> b
forall ann a. (a -> a -> a) -> AnnUnit ann a -> a
forall ann m a. Monoid m => (a -> m) -> AnnUnit ann a -> m
forall ann b a. (b -> a -> b) -> b -> AnnUnit ann a -> b
forall ann a b. (a -> b -> b) -> b -> AnnUnit ann 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
product :: AnnUnit ann a -> a
$cproduct :: forall ann a. Num a => AnnUnit ann a -> a
sum :: AnnUnit ann a -> a
$csum :: forall ann a. Num a => AnnUnit ann a -> a
minimum :: AnnUnit ann a -> a
$cminimum :: forall ann a. Ord a => AnnUnit ann a -> a
maximum :: AnnUnit ann a -> a
$cmaximum :: forall ann a. Ord a => AnnUnit ann a -> a
elem :: a -> AnnUnit ann a -> Bool
$celem :: forall ann a. Eq a => a -> AnnUnit ann a -> Bool
length :: AnnUnit ann a -> Int
$clength :: forall ann a. AnnUnit ann a -> Int
null :: AnnUnit ann a -> Bool
$cnull :: forall ann a. AnnUnit ann a -> Bool
toList :: AnnUnit ann a -> [a]
$ctoList :: forall ann a. AnnUnit ann a -> [a]
foldl1 :: (a -> a -> a) -> AnnUnit ann a -> a
$cfoldl1 :: forall ann a. (a -> a -> a) -> AnnUnit ann a -> a
foldr1 :: (a -> a -> a) -> AnnUnit ann a -> a
$cfoldr1 :: forall ann a. (a -> a -> a) -> AnnUnit ann a -> a
foldl' :: (b -> a -> b) -> b -> AnnUnit ann a -> b
$cfoldl' :: forall ann b a. (b -> a -> b) -> b -> AnnUnit ann a -> b
foldl :: (b -> a -> b) -> b -> AnnUnit ann a -> b
$cfoldl :: forall ann b a. (b -> a -> b) -> b -> AnnUnit ann a -> b
foldr' :: (a -> b -> b) -> b -> AnnUnit ann a -> b
$cfoldr' :: forall ann a b. (a -> b -> b) -> b -> AnnUnit ann a -> b
foldr :: (a -> b -> b) -> b -> AnnUnit ann a -> b
$cfoldr :: forall ann a b. (a -> b -> b) -> b -> AnnUnit ann a -> b
foldMap' :: (a -> m) -> AnnUnit ann a -> m
$cfoldMap' :: forall ann m a. Monoid m => (a -> m) -> AnnUnit ann a -> m
foldMap :: (a -> m) -> AnnUnit ann a -> m
$cfoldMap :: forall ann m a. Monoid m => (a -> m) -> AnnUnit ann a -> m
fold :: AnnUnit ann m -> m
$cfold :: forall ann m. Monoid m => AnnUnit ann m -> m
Foldable, Functor (AnnUnit ann)
Foldable (AnnUnit ann)
Functor (AnnUnit ann)
-> Foldable (AnnUnit ann)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AnnUnit ann a -> f (AnnUnit ann b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AnnUnit ann (f a) -> f (AnnUnit ann a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AnnUnit ann a -> m (AnnUnit ann b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AnnUnit ann (m a) -> m (AnnUnit ann a))
-> Traversable (AnnUnit ann)
(a -> f b) -> AnnUnit ann a -> f (AnnUnit ann b)
forall ann. Functor (AnnUnit ann)
forall ann. Foldable (AnnUnit ann)
forall ann (m :: * -> *) a.
Monad m =>
AnnUnit ann (m a) -> m (AnnUnit ann a)
forall ann (f :: * -> *) a.
Applicative f =>
AnnUnit ann (f a) -> f (AnnUnit ann a)
forall ann (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnnUnit ann a -> m (AnnUnit ann b)
forall ann (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnnUnit ann a -> f (AnnUnit ann b)
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 =>
AnnUnit ann (m a) -> m (AnnUnit ann a)
forall (f :: * -> *) a.
Applicative f =>
AnnUnit ann (f a) -> f (AnnUnit ann a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnnUnit ann a -> m (AnnUnit ann b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnnUnit ann a -> f (AnnUnit ann b)
sequence :: AnnUnit ann (m a) -> m (AnnUnit ann a)
$csequence :: forall ann (m :: * -> *) a.
Monad m =>
AnnUnit ann (m a) -> m (AnnUnit ann a)
mapM :: (a -> m b) -> AnnUnit ann a -> m (AnnUnit ann b)
$cmapM :: forall ann (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnnUnit ann a -> m (AnnUnit ann b)
sequenceA :: AnnUnit ann (f a) -> f (AnnUnit ann a)
$csequenceA :: forall ann (f :: * -> *) a.
Applicative f =>
AnnUnit ann (f a) -> f (AnnUnit ann a)
traverse :: (a -> f b) -> AnnUnit ann a -> f (AnnUnit ann b)
$ctraverse :: forall ann (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnnUnit ann a -> f (AnnUnit ann b)
$cp2Traversable :: forall ann. Foldable (AnnUnit ann)
$cp1Traversable :: forall ann. Functor (AnnUnit ann)
Traversable
  , Int -> AnnUnit ann expr -> ShowS
[AnnUnit ann expr] -> ShowS
AnnUnit ann expr -> String
(Int -> AnnUnit ann expr -> ShowS)
-> (AnnUnit ann expr -> String)
-> ([AnnUnit ann expr] -> ShowS)
-> Show (AnnUnit ann expr)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall ann expr.
(Show ann, Show expr) =>
Int -> AnnUnit ann expr -> ShowS
forall ann expr.
(Show ann, Show expr) =>
[AnnUnit ann expr] -> ShowS
forall ann expr.
(Show ann, Show expr) =>
AnnUnit ann expr -> String
showList :: [AnnUnit ann expr] -> ShowS
$cshowList :: forall ann expr.
(Show ann, Show expr) =>
[AnnUnit ann expr] -> ShowS
show :: AnnUnit ann expr -> String
$cshow :: forall ann expr.
(Show ann, Show expr) =>
AnnUnit ann expr -> String
showsPrec :: Int -> AnnUnit ann expr -> ShowS
$cshowsPrec :: forall ann expr.
(Show ann, Show expr) =>
Int -> AnnUnit ann expr -> ShowS
Show, ReadPrec [AnnUnit ann expr]
ReadPrec (AnnUnit ann expr)
Int -> ReadS (AnnUnit ann expr)
ReadS [AnnUnit ann expr]
(Int -> ReadS (AnnUnit ann expr))
-> ReadS [AnnUnit ann expr]
-> ReadPrec (AnnUnit ann expr)
-> ReadPrec [AnnUnit ann expr]
-> Read (AnnUnit ann expr)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall ann expr.
(Read ann, Read expr) =>
ReadPrec [AnnUnit ann expr]
forall ann expr.
(Read ann, Read expr) =>
ReadPrec (AnnUnit ann expr)
forall ann expr.
(Read ann, Read expr) =>
Int -> ReadS (AnnUnit ann expr)
forall ann expr. (Read ann, Read expr) => ReadS [AnnUnit ann expr]
readListPrec :: ReadPrec [AnnUnit ann expr]
$creadListPrec :: forall ann expr.
(Read ann, Read expr) =>
ReadPrec [AnnUnit ann expr]
readPrec :: ReadPrec (AnnUnit ann expr)
$creadPrec :: forall ann expr.
(Read ann, Read expr) =>
ReadPrec (AnnUnit ann expr)
readList :: ReadS [AnnUnit ann expr]
$creadList :: forall ann expr. (Read ann, Read expr) => ReadS [AnnUnit ann expr]
readsPrec :: Int -> ReadS (AnnUnit ann expr)
$creadsPrec :: forall ann expr.
(Read ann, Read expr) =>
Int -> ReadS (AnnUnit ann expr)
Read
  )

type AnnF ann f = Compose (AnnUnit ann) f

-- | Pattern: @(Compose (AnnUnit _ _))@.
pattern AnnF
  :: ann
  -> f a
  -> Compose (AnnUnit ann) f a
pattern $bAnnF :: ann -> f a -> Compose (AnnUnit ann) f a
$mAnnF :: forall r ann (f :: * -> *) a.
Compose (AnnUnit ann) f a -> (ann -> f a -> r) -> (Void# -> r) -> r
AnnF ann f = Compose (AnnUnit ann f)
{-# complete AnnF #-}


type Ann ann f = Fix (AnnF ann f)

-- | Pattern: @Fix (Compose (AnnUnit _ _))@.
-- Fix composes units of (annotations & the annotated) into one object.
-- Giving annotated expression.
pattern Ann
  :: forall ann (f :: Type -> Type)
  . ann
  -> f (Ann ann f)
  -> Ann ann f
pattern $bAnn :: ann -> f (Ann ann f) -> Ann ann f
$mAnn :: forall r ann (f :: * -> *).
Ann ann f -> (ann -> f (Ann ann f) -> r) -> (Void# -> r) -> r
Ann ann a = Fix (AnnF ann a)
{-# complete Ann #-}

annUnitToAnn :: AnnUnit ann (f (Ann ann f)) -> Ann ann f
annUnitToAnn :: AnnUnit ann (f (Ann ann f)) -> Ann ann f
annUnitToAnn (AnnUnit ann
ann f (Ann ann f)
a) = ann -> f (Ann ann f) -> Ann ann f
forall ann (f :: * -> *). ann -> f (Ann ann f) -> Ann ann f
Ann ann
ann f (Ann ann f)
a

-- ** Instances

instance NFData ann => NFData1 (AnnUnit ann)

instance (Binary ann, Binary a) => Binary (AnnUnit ann a)

$(deriveEq1   ''AnnUnit)
$(deriveEq2   ''AnnUnit)
$(deriveOrd1  ''AnnUnit)
$(deriveOrd2  ''AnnUnit)
$(deriveRead1 ''AnnUnit)
$(deriveRead2 ''AnnUnit)
$(deriveShow1 ''AnnUnit)
$(deriveShow2 ''AnnUnit)
$(deriveJSON1 defaultOptions ''AnnUnit)
$(deriveJSON2 defaultOptions ''AnnUnit)

instance Hashable ann => Hashable1 (AnnUnit ann)

instance (Serialise ann, Serialise a) => Serialise (AnnUnit ann a)

-- ** @NExprLoc{,F}@ - annotated Nix expression

type NExprLocF = AnnF SrcSpan NExprF

instance Serialise r => Serialise (NExprLocF r) where
  encode :: NExprLocF r -> Encoding
encode (AnnF SrcSpan
ann NExprF r
a) = SrcSpan -> Encoding
forall a. Serialise a => a -> Encoding
encode SrcSpan
ann Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> NExprF r -> Encoding
forall a. Serialise a => a -> Encoding
encode NExprF r
a
  decode :: Decoder s (NExprLocF r)
decode =
    (SrcSpan -> NExprF r -> NExprLocF r)
-> Decoder s SrcSpan
-> Decoder s (NExprF r)
-> Decoder s (NExprLocF r)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 SrcSpan -> NExprF r -> NExprLocF r
forall ann (f :: * -> *) a. ann -> f a -> Compose (AnnUnit ann) f a
AnnF
      Decoder s SrcSpan
forall a s. Serialise a => Decoder s a
decode
      Decoder s (NExprF r)
forall a s. Serialise a => Decoder s a
decode

instance Binary r => Binary (NExprLocF r)

-- | Annotated Nix expression (each subexpression direct to its source location).
type NExprLoc = Fix NExprLocF

instance Serialise NExprLoc

instance Binary NExprLoc

-- * Other

stripAnnF :: AnnF ann f r -> f r
stripAnnF :: AnnF ann f r -> f r
stripAnnF = AnnUnit ann (f r) -> f r
forall ann expr. AnnUnit ann expr -> expr
annotated (AnnUnit ann (f r) -> f r)
-> (AnnF ann f r -> AnnUnit ann (f r)) -> AnnF ann f r -> f r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnnF ann f r -> AnnUnit ann (f r)
forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose

stripAnnotation :: Functor f => Ann ann f -> Fix f
stripAnnotation :: Ann ann f -> Fix f
stripAnnotation = (Ann ann f -> f (Ann ann f)) -> Ann ann f -> Fix f
forall (f :: * -> *) a. Functor f => (a -> f a) -> a -> Fix f
unfoldFix (AnnF ann f (Ann ann f) -> f (Ann ann f)
forall ann (f :: * -> *) r. AnnF ann f r -> f r
stripAnnF (AnnF ann f (Ann ann f) -> f (Ann ann f))
-> (Ann ann f -> AnnF ann f (Ann ann f))
-> Ann ann f
-> f (Ann ann f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ann ann f -> AnnF ann f (Ann ann f)
forall (f :: * -> *). Fix f -> f (Fix f)
unFix)

annNUnary :: AnnUnit SrcSpan NUnaryOp -> NExprLoc -> NExprLoc
annNUnary :: AnnUnit SrcSpan NUnaryOp -> NExprLoc -> NExprLoc
annNUnary (AnnUnit SrcSpan
s1 NUnaryOp
u) e1 :: NExprLoc
e1@(Ann SrcSpan
s2 NExprF NExprLoc
_) = SrcSpan -> NUnaryOp -> NExprLoc -> NExprLoc
NUnaryAnn (SrcSpan
s1 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s2) NUnaryOp
u NExprLoc
e1
{-# inline annNUnary #-}

annNBinary :: AnnUnit SrcSpan NBinaryOp -> NExprLoc -> NExprLoc -> NExprLoc
annNBinary :: AnnUnit SrcSpan NBinaryOp -> NExprLoc -> NExprLoc -> NExprLoc
annNBinary (AnnUnit SrcSpan
s1 NBinaryOp
b) e1 :: NExprLoc
e1@(Ann SrcSpan
s2 NExprF NExprLoc
_) e2 :: NExprLoc
e2@(Ann SrcSpan
s3 NExprF NExprLoc
_) = SrcSpan -> NBinaryOp -> NExprLoc -> NExprLoc -> NExprLoc
NBinaryAnn (SrcSpan
s1 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s2 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s3) NBinaryOp
b NExprLoc
e1 NExprLoc
e2

annNSelect
  :: Maybe NExprLoc -> NExprLoc -> AnnUnit SrcSpan (NAttrPath NExprLoc) -> NExprLoc
annNSelect :: Maybe NExprLoc
-> NExprLoc -> AnnUnit SrcSpan (NAttrPath NExprLoc) -> NExprLoc
annNSelect  Maybe NExprLoc
Nothing             e2 :: NExprLoc
e2@(Ann SrcSpan
s2 NExprF NExprLoc
_) (AnnUnit SrcSpan
s1 NAttrPath NExprLoc
ats) = SrcSpan
-> Maybe NExprLoc -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
NSelectAnn (      SrcSpan
s2 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s1)  Maybe NExprLoc
forall a. Maybe a
Nothing  NExprLoc
e2 NAttrPath NExprLoc
ats
annNSelect (Just e3 :: NExprLoc
e3@(Ann SrcSpan
s3 NExprF NExprLoc
_)) e2 :: NExprLoc
e2@(Ann SrcSpan
s2 NExprF NExprLoc
_) (AnnUnit SrcSpan
s1 NAttrPath NExprLoc
ats) = SrcSpan
-> Maybe NExprLoc -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
NSelectAnn (SrcSpan
s3 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s2 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s1) (NExprLoc -> Maybe NExprLoc
forall (f :: * -> *) a. Applicative f => a -> f a
pure NExprLoc
e3) NExprLoc
e2 NAttrPath NExprLoc
ats

annNHasAttr :: NExprLoc -> AnnUnit SrcSpan (NAttrPath NExprLoc) -> NExprLoc
annNHasAttr :: NExprLoc -> AnnUnit SrcSpan (NAttrPath NExprLoc) -> NExprLoc
annNHasAttr e1 :: NExprLoc
e1@(Ann SrcSpan
s1 NExprF NExprLoc
_) (AnnUnit SrcSpan
s2 NAttrPath NExprLoc
ats) = SrcSpan -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
NHasAttrAnn (SrcSpan
s1 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s2) NExprLoc
e1 NAttrPath NExprLoc
ats

annNApp :: NExprLoc -> NExprLoc -> NExprLoc
annNApp :: NExprLoc -> NExprLoc -> NExprLoc
annNApp e1 :: NExprLoc
e1@(Ann SrcSpan
s1 NExprF NExprLoc
_) e2 :: NExprLoc
e2@(Ann SrcSpan
s2 NExprF NExprLoc
_) = SrcSpan -> NBinaryOp -> NExprLoc -> NExprLoc -> NExprLoc
NBinaryAnn (SrcSpan
s1 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s2) NBinaryOp
NApp NExprLoc
e1 NExprLoc
e2

annNAbs :: AnnUnit SrcSpan (Params NExprLoc) -> NExprLoc -> NExprLoc
annNAbs :: AnnUnit SrcSpan (Params NExprLoc) -> NExprLoc -> NExprLoc
annNAbs (AnnUnit SrcSpan
s1 Params NExprLoc
ps) e1 :: NExprLoc
e1@(Ann SrcSpan
s2 NExprF NExprLoc
_) = SrcSpan -> Params NExprLoc -> NExprLoc -> NExprLoc
NAbsAnn (SrcSpan
s1 SrcSpan -> SrcSpan -> SrcSpan
forall a. Semigroup a => a -> a -> a
<> SrcSpan
s2) Params NExprLoc
ps NExprLoc
e1

annNStr :: AnnUnit SrcSpan (NString NExprLoc) -> NExprLoc
annNStr :: AnnUnit SrcSpan (NString NExprLoc) -> NExprLoc
annNStr (AnnUnit SrcSpan
s1 NString NExprLoc
s) = SrcSpan -> NString NExprLoc -> NExprLoc
NStrAnn SrcSpan
s1 NString NExprLoc
s

deltaInfo :: SourcePos -> (Text, Int, Int)
deltaInfo :: SourcePos -> (Text, Int, Int)
deltaInfo (SourcePos String
fp Pos
l Pos
c) = (String -> Text
forall a. IsString a => String -> a
fromString String
fp, Pos -> Int
unPos Pos
l, Pos -> Int
unPos Pos
c)

annNNull :: NExprLoc
annNNull :: NExprLoc
annNNull = SrcSpan -> NAtom -> NExprLoc
NConstantAnn SrcSpan
nullSpan NAtom
NNull
{-# inline annNNull #-}

nullSpan :: SrcSpan
nullSpan :: SrcSpan
nullSpan = SourcePos -> SourcePos -> SrcSpan
SrcSpan SourcePos
nullPos SourcePos
nullPos
{-# inline nullSpan #-}

-- | Pattern systems for matching on @NExprLocF@ constructions.

pattern NConstantAnnF    :: SrcSpan -> NAtom -> NExprLocF r
pattern $bNConstantAnnF :: SrcSpan -> NAtom -> NExprLocF r
$mNConstantAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> NAtom -> r) -> (Void# -> r) -> r
NConstantAnnF    ann x      = AnnF ann (NConstant x)

pattern NStrAnnF         :: SrcSpan -> NString r -> NExprLocF r
pattern $bNStrAnnF :: SrcSpan -> NString r -> NExprLocF r
$mNStrAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> NString r -> r) -> (Void# -> r) -> r
NStrAnnF         ann x      = AnnF ann (NStr x)

pattern NSymAnnF         :: SrcSpan -> VarName -> NExprLocF r
pattern $bNSymAnnF :: SrcSpan -> VarName -> NExprLocF r
$mNSymAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> VarName -> r) -> (Void# -> r) -> r
NSymAnnF         ann x      = AnnF ann (NSym x)

pattern NListAnnF        :: SrcSpan -> [r] -> NExprLocF r
pattern $bNListAnnF :: SrcSpan -> [r] -> NExprLocF r
$mNListAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> [r] -> r) -> (Void# -> r) -> r
NListAnnF        ann x      = AnnF ann (NList x)

pattern NSetAnnF         :: SrcSpan -> Recursivity -> [Binding r] -> NExprLocF r
pattern $bNSetAnnF :: SrcSpan -> Recursivity -> [Binding r] -> NExprLocF r
$mNSetAnnF :: forall r r.
NExprLocF r
-> (SrcSpan -> Recursivity -> [Binding r] -> r)
-> (Void# -> r)
-> r
NSetAnnF         ann rec x  = AnnF ann (NSet rec x)

pattern NLiteralPathAnnF :: SrcSpan -> Path -> NExprLocF r
pattern $bNLiteralPathAnnF :: SrcSpan -> Path -> NExprLocF r
$mNLiteralPathAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> Path -> r) -> (Void# -> r) -> r
NLiteralPathAnnF ann x      = AnnF ann (NLiteralPath x)

pattern NEnvPathAnnF     :: SrcSpan -> Path -> NExprLocF r
pattern $bNEnvPathAnnF :: SrcSpan -> Path -> NExprLocF r
$mNEnvPathAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> Path -> r) -> (Void# -> r) -> r
NEnvPathAnnF     ann x      = AnnF ann (NEnvPath x)

pattern NUnaryAnnF       :: SrcSpan -> NUnaryOp -> r -> NExprLocF r
pattern $bNUnaryAnnF :: SrcSpan -> NUnaryOp -> r -> NExprLocF r
$mNUnaryAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> NUnaryOp -> r -> r) -> (Void# -> r) -> r
NUnaryAnnF       ann op x   = AnnF ann (NUnary op x)

pattern NBinaryAnnF      :: SrcSpan -> NBinaryOp -> r -> r -> NExprLocF r
pattern $bNBinaryAnnF :: SrcSpan -> NBinaryOp -> r -> r -> NExprLocF r
$mNBinaryAnnF :: forall r r.
NExprLocF r
-> (SrcSpan -> NBinaryOp -> r -> r -> r) -> (Void# -> r) -> r
NBinaryAnnF      ann op x y = AnnF ann (NBinary op x y)

pattern NSelectAnnF      :: SrcSpan ->  Maybe r -> r -> NAttrPath r -> NExprLocF r
pattern $bNSelectAnnF :: SrcSpan -> Maybe r -> r -> NAttrPath r -> NExprLocF r
$mNSelectAnnF :: forall r r.
NExprLocF r
-> (SrcSpan -> Maybe r -> r -> NAttrPath r -> r)
-> (Void# -> r)
-> r
NSelectAnnF      ann v x p  = AnnF ann (NSelect v x p)

pattern NHasAttrAnnF     :: SrcSpan -> r -> NAttrPath r -> NExprLocF r
pattern $bNHasAttrAnnF :: SrcSpan -> r -> NAttrPath r -> NExprLocF r
$mNHasAttrAnnF :: forall r r.
NExprLocF r
-> (SrcSpan -> r -> NAttrPath r -> r) -> (Void# -> r) -> r
NHasAttrAnnF     ann x p    = AnnF ann (NHasAttr x p)

pattern NAbsAnnF         :: SrcSpan -> Params r-> r -> NExprLocF r
pattern $bNAbsAnnF :: SrcSpan -> Params r -> r -> NExprLocF r
$mNAbsAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> Params r -> r -> r) -> (Void# -> r) -> r
NAbsAnnF         ann x b    = AnnF ann (NAbs x b)

pattern NLetAnnF         :: SrcSpan -> [Binding r] -> r -> NExprLocF r
pattern $bNLetAnnF :: SrcSpan -> [Binding r] -> r -> NExprLocF r
$mNLetAnnF :: forall r r.
NExprLocF r
-> (SrcSpan -> [Binding r] -> r -> r) -> (Void# -> r) -> r
NLetAnnF         ann x b    = AnnF ann (NLet x b)

pattern NIfAnnF          :: SrcSpan -> r -> r -> r -> NExprLocF r
pattern $bNIfAnnF :: SrcSpan -> r -> r -> r -> NExprLocF r
$mNIfAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> r -> r -> r -> r) -> (Void# -> r) -> r
NIfAnnF          ann c t e  = AnnF ann (NIf c t e)

pattern NWithAnnF        :: SrcSpan -> r -> r -> NExprLocF r
pattern $bNWithAnnF :: SrcSpan -> r -> r -> NExprLocF r
$mNWithAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> r -> r -> r) -> (Void# -> r) -> r
NWithAnnF        ann x y    = AnnF ann (NWith x y)

pattern NAssertAnnF      :: SrcSpan -> r -> r -> NExprLocF r
pattern $bNAssertAnnF :: SrcSpan -> r -> r -> NExprLocF r
$mNAssertAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> r -> r -> r) -> (Void# -> r) -> r
NAssertAnnF      ann x y    = AnnF ann (NAssert x y)

pattern NSynHoleAnnF     :: SrcSpan -> VarName -> NExprLocF r
pattern $bNSynHoleAnnF :: SrcSpan -> VarName -> NExprLocF r
$mNSynHoleAnnF :: forall r r.
NExprLocF r -> (SrcSpan -> VarName -> r) -> (Void# -> r) -> r
NSynHoleAnnF     ann x      = AnnF ann (NSynHole x)
{-# complete NConstantAnnF, NStrAnnF, NSymAnnF, NListAnnF, NSetAnnF, NLiteralPathAnnF, NEnvPathAnnF, NUnaryAnnF, NBinaryAnnF, NSelectAnnF, NHasAttrAnnF, NAbsAnnF, NLetAnnF, NIfAnnF, NWithAnnF, NAssertAnnF, NSynHoleAnnF #-}


pattern NConstantAnn    :: SrcSpan -> NAtom -> NExprLoc
pattern $bNConstantAnn :: SrcSpan -> NAtom -> NExprLoc
$mNConstantAnn :: forall r. NExprLoc -> (SrcSpan -> NAtom -> r) -> (Void# -> r) -> r
NConstantAnn    ann x      = Ann ann (NConstant x)

pattern NStrAnn         :: SrcSpan -> NString NExprLoc -> NExprLoc
pattern $bNStrAnn :: SrcSpan -> NString NExprLoc -> NExprLoc
$mNStrAnn :: forall r.
NExprLoc -> (SrcSpan -> NString NExprLoc -> r) -> (Void# -> r) -> r
NStrAnn         ann x      = Ann ann (NStr x)

pattern NSymAnn         :: SrcSpan -> VarName -> NExprLoc
pattern $bNSymAnn :: SrcSpan -> VarName -> NExprLoc
$mNSymAnn :: forall r.
NExprLoc -> (SrcSpan -> VarName -> r) -> (Void# -> r) -> r
NSymAnn         ann x      = Ann ann (NSym x)

pattern NListAnn        :: SrcSpan -> [NExprLoc] -> NExprLoc
pattern $bNListAnn :: SrcSpan -> [NExprLoc] -> NExprLoc
$mNListAnn :: forall r.
NExprLoc -> (SrcSpan -> [NExprLoc] -> r) -> (Void# -> r) -> r
NListAnn        ann x      = Ann ann (NList x)

pattern NSetAnn         :: SrcSpan -> Recursivity -> [Binding NExprLoc] -> NExprLoc
pattern $bNSetAnn :: SrcSpan -> Recursivity -> [Binding NExprLoc] -> NExprLoc
$mNSetAnn :: forall r.
NExprLoc
-> (SrcSpan -> Recursivity -> [Binding NExprLoc] -> r)
-> (Void# -> r)
-> r
NSetAnn         ann rec x  = Ann ann (NSet rec x)

pattern NLiteralPathAnn :: SrcSpan -> Path -> NExprLoc
pattern $bNLiteralPathAnn :: SrcSpan -> Path -> NExprLoc
$mNLiteralPathAnn :: forall r. NExprLoc -> (SrcSpan -> Path -> r) -> (Void# -> r) -> r
NLiteralPathAnn ann x      = Ann ann (NLiteralPath x)

pattern NEnvPathAnn     :: SrcSpan -> Path -> NExprLoc
pattern $bNEnvPathAnn :: SrcSpan -> Path -> NExprLoc
$mNEnvPathAnn :: forall r. NExprLoc -> (SrcSpan -> Path -> r) -> (Void# -> r) -> r
NEnvPathAnn     ann x      = Ann ann (NEnvPath x)

pattern NUnaryAnn       :: SrcSpan -> NUnaryOp -> NExprLoc -> NExprLoc
pattern $bNUnaryAnn :: SrcSpan -> NUnaryOp -> NExprLoc -> NExprLoc
$mNUnaryAnn :: forall r.
NExprLoc
-> (SrcSpan -> NUnaryOp -> NExprLoc -> r) -> (Void# -> r) -> r
NUnaryAnn       ann op x   = Ann ann (NUnary op x)

pattern NBinaryAnn      :: SrcSpan -> NBinaryOp -> NExprLoc -> NExprLoc -> NExprLoc
pattern $bNBinaryAnn :: SrcSpan -> NBinaryOp -> NExprLoc -> NExprLoc -> NExprLoc
$mNBinaryAnn :: forall r.
NExprLoc
-> (SrcSpan -> NBinaryOp -> NExprLoc -> NExprLoc -> r)
-> (Void# -> r)
-> r
NBinaryAnn      ann op x y = Ann ann (NBinary op x y)

pattern NSelectAnn      :: SrcSpan ->  Maybe NExprLoc -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
pattern $bNSelectAnn :: SrcSpan
-> Maybe NExprLoc -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
$mNSelectAnn :: forall r.
NExprLoc
-> (SrcSpan
    -> Maybe NExprLoc -> NExprLoc -> NAttrPath NExprLoc -> r)
-> (Void# -> r)
-> r
NSelectAnn      ann v x p  = Ann ann (NSelect v x p)

pattern NHasAttrAnn     :: SrcSpan -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
pattern $bNHasAttrAnn :: SrcSpan -> NExprLoc -> NAttrPath NExprLoc -> NExprLoc
$mNHasAttrAnn :: forall r.
NExprLoc
-> (SrcSpan -> NExprLoc -> NAttrPath NExprLoc -> r)
-> (Void# -> r)
-> r
NHasAttrAnn     ann x p    = Ann ann (NHasAttr x p)

pattern NAbsAnn         :: SrcSpan -> Params NExprLoc -> NExprLoc -> NExprLoc
pattern $bNAbsAnn :: SrcSpan -> Params NExprLoc -> NExprLoc -> NExprLoc
$mNAbsAnn :: forall r.
NExprLoc
-> (SrcSpan -> Params NExprLoc -> NExprLoc -> r)
-> (Void# -> r)
-> r
NAbsAnn         ann x b    = Ann ann (NAbs x b)

pattern NLetAnn         :: SrcSpan -> [Binding NExprLoc] -> NExprLoc -> NExprLoc
pattern $bNLetAnn :: SrcSpan -> [Binding NExprLoc] -> NExprLoc -> NExprLoc
$mNLetAnn :: forall r.
NExprLoc
-> (SrcSpan -> [Binding NExprLoc] -> NExprLoc -> r)
-> (Void# -> r)
-> r
NLetAnn         ann x b    = Ann ann (NLet x b)

pattern NIfAnn          :: SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc -> NExprLoc
pattern $bNIfAnn :: SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc -> NExprLoc
$mNIfAnn :: forall r.
NExprLoc
-> (SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc -> r)
-> (Void# -> r)
-> r
NIfAnn          ann c t e  = Ann ann (NIf c t e)

pattern NWithAnn        :: SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc
pattern $bNWithAnn :: SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc
$mNWithAnn :: forall r.
NExprLoc
-> (SrcSpan -> NExprLoc -> NExprLoc -> r) -> (Void# -> r) -> r
NWithAnn        ann x y    = Ann ann (NWith x y)

pattern NAssertAnn      :: SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc
pattern $bNAssertAnn :: SrcSpan -> NExprLoc -> NExprLoc -> NExprLoc
$mNAssertAnn :: forall r.
NExprLoc
-> (SrcSpan -> NExprLoc -> NExprLoc -> r) -> (Void# -> r) -> r
NAssertAnn      ann x y    = Ann ann (NAssert x y)

pattern NSynHoleAnn     :: SrcSpan -> VarName -> NExprLoc
pattern $bNSynHoleAnn :: SrcSpan -> VarName -> NExprLoc
$mNSynHoleAnn :: forall r.
NExprLoc -> (SrcSpan -> VarName -> r) -> (Void# -> r) -> r
NSynHoleAnn     ann x      = Ann ann (NSynHole x)
{-# complete NConstantAnn, NStrAnn, NSymAnn, NListAnn, NSetAnn, NLiteralPathAnn, NEnvPathAnn, NUnaryAnn, NBinaryAnn, NSelectAnn, NHasAttrAnn, NAbsAnn, NLetAnn, NIfAnn, NWithAnn, NAssertAnn, NSynHoleAnn #-}