{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable,
             DeriveTraversable, StandaloneDeriving, CPP #-}
module Language.Haskell.Names.Types where

import Language.Haskell.Exts
import Data.Typeable
import Data.Data
import Data.Foldable as F
import Data.Map (Map)
import Text.Printf


-- | Information about an entity. Carries at least the module it was originally
-- declared in and its name.
data Symbol
    = Value
      { Symbol -> ModuleName ()
symbolModule :: ModuleName ()
      , Symbol -> Name ()
symbolName :: Name ()
      }
      -- ^ value or function
    | Method
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , Symbol -> Name ()
className :: Name ()
      }
      -- ^ class method
    | Selector
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , Symbol -> Name ()
typeName :: Name ()
      , Symbol -> [Name ()]
constructors :: [Name ()]
      }
      -- ^ record field selector
    | Constructor
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , typeName :: Name ()
      }
      -- ^ data constructor
    | Type
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      }
      -- ^ type synonym
    | Data
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      }
      -- ^ data type
    | NewType
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      }
      -- ^ newtype
    | TypeFam
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , Symbol -> Maybe (Name ())
associate :: Maybe (Name ())
      }
      -- ^ type family
    | DataFam
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , associate :: Maybe (Name ())
      }
      -- ^ data family
    | Class
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      }
      -- ^ type class
    | PatternConstructor
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , Symbol -> Maybe (Name ())
patternTypeName :: Maybe (Name ())
      }
      -- ^ pattern synonym constructor
    | PatternSelector
      { symbolModule :: ModuleName ()
      , symbolName :: Name ()
      , patternTypeName :: Maybe (Name ())
      , Symbol -> Name ()
patternConstructorName :: Name ()
      }
      -- ^ pattern synonym selector
    deriving (Symbol -> Symbol -> Bool
(Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool) -> Eq Symbol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Symbol -> Symbol -> Bool
== :: Symbol -> Symbol -> Bool
$c/= :: Symbol -> Symbol -> Bool
/= :: Symbol -> Symbol -> Bool
Eq, Eq Symbol
Eq Symbol =>
(Symbol -> Symbol -> Ordering)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Bool)
-> (Symbol -> Symbol -> Symbol)
-> (Symbol -> Symbol -> Symbol)
-> Ord Symbol
Symbol -> Symbol -> Bool
Symbol -> Symbol -> Ordering
Symbol -> Symbol -> Symbol
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
$ccompare :: Symbol -> Symbol -> Ordering
compare :: Symbol -> Symbol -> Ordering
$c< :: Symbol -> Symbol -> Bool
< :: Symbol -> Symbol -> Bool
$c<= :: Symbol -> Symbol -> Bool
<= :: Symbol -> Symbol -> Bool
$c> :: Symbol -> Symbol -> Bool
> :: Symbol -> Symbol -> Bool
$c>= :: Symbol -> Symbol -> Bool
>= :: Symbol -> Symbol -> Bool
$cmax :: Symbol -> Symbol -> Symbol
max :: Symbol -> Symbol -> Symbol
$cmin :: Symbol -> Symbol -> Symbol
min :: Symbol -> Symbol -> Symbol
Ord, Int -> Symbol -> ShowS
[Symbol] -> ShowS
Symbol -> String
(Int -> Symbol -> ShowS)
-> (Symbol -> String) -> ([Symbol] -> ShowS) -> Show Symbol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Symbol -> ShowS
showsPrec :: Int -> Symbol -> ShowS
$cshow :: Symbol -> String
show :: Symbol -> String
$cshowList :: [Symbol] -> ShowS
showList :: [Symbol] -> ShowS
Show, Typeable Symbol
Typeable Symbol =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Symbol -> c Symbol)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Symbol)
-> (Symbol -> Constr)
-> (Symbol -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Symbol))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol))
-> ((forall b. Data b => b -> b) -> Symbol -> Symbol)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Symbol -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Symbol -> r)
-> (forall u. (forall d. Data d => d -> u) -> Symbol -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Symbol -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Symbol -> m Symbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Symbol -> m Symbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Symbol -> m Symbol)
-> Data Symbol
Symbol -> Constr
Symbol -> DataType
(forall b. Data b => b -> b) -> Symbol -> Symbol
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) -> Symbol -> u
forall u. (forall d. Data d => d -> u) -> Symbol -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Symbol
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Symbol -> c Symbol
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Symbol)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Symbol -> c Symbol
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Symbol -> c Symbol
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Symbol
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Symbol
$ctoConstr :: Symbol -> Constr
toConstr :: Symbol -> Constr
$cdataTypeOf :: Symbol -> DataType
dataTypeOf :: Symbol -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Symbol)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Symbol)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol)
$cgmapT :: (forall b. Data b => b -> b) -> Symbol -> Symbol
gmapT :: (forall b. Data b => b -> b) -> Symbol -> Symbol
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Symbol -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Symbol -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Symbol -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Symbol -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Symbol -> m Symbol
Data, Typeable)

-- | A map from module name to list of symbols it exports.
type Environment = Map (ModuleName ()) [Symbol]

-- | A pair of the name information and original annotation. Used as an
-- annotation type for AST.
data Scoped l = Scoped (NameInfo l) l
  deriving ((forall a b. (a -> b) -> Scoped a -> Scoped b)
-> (forall a b. a -> Scoped b -> Scoped a) -> Functor Scoped
forall a b. a -> Scoped b -> Scoped a
forall a b. (a -> b) -> Scoped a -> Scoped 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) -> Scoped a -> Scoped b
fmap :: forall a b. (a -> b) -> Scoped a -> Scoped b
$c<$ :: forall a b. a -> Scoped b -> Scoped a
<$ :: forall a b. a -> Scoped b -> Scoped a
Functor, (forall m. Monoid m => Scoped m -> m)
-> (forall m a. Monoid m => (a -> m) -> Scoped a -> m)
-> (forall m a. Monoid m => (a -> m) -> Scoped a -> m)
-> (forall a b. (a -> b -> b) -> b -> Scoped a -> b)
-> (forall a b. (a -> b -> b) -> b -> Scoped a -> b)
-> (forall b a. (b -> a -> b) -> b -> Scoped a -> b)
-> (forall b a. (b -> a -> b) -> b -> Scoped a -> b)
-> (forall a. (a -> a -> a) -> Scoped a -> a)
-> (forall a. (a -> a -> a) -> Scoped a -> a)
-> (forall a. Scoped a -> [a])
-> (forall a. Scoped a -> Bool)
-> (forall a. Scoped a -> Int)
-> (forall a. Eq a => a -> Scoped a -> Bool)
-> (forall a. Ord a => Scoped a -> a)
-> (forall a. Ord a => Scoped a -> a)
-> (forall a. Num a => Scoped a -> a)
-> (forall a. Num a => Scoped a -> a)
-> Foldable Scoped
forall a. Eq a => a -> Scoped a -> Bool
forall a. Num a => Scoped a -> a
forall a. Ord a => Scoped a -> a
forall m. Monoid m => Scoped m -> m
forall a. Scoped a -> Bool
forall a. Scoped a -> Int
forall a. Scoped a -> [a]
forall a. (a -> a -> a) -> Scoped a -> a
forall m a. Monoid m => (a -> m) -> Scoped a -> m
forall b a. (b -> a -> b) -> b -> Scoped a -> b
forall a b. (a -> b -> b) -> b -> Scoped 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 => Scoped m -> m
fold :: forall m. Monoid m => Scoped m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Scoped a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Scoped a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Scoped a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Scoped a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Scoped a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Scoped a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Scoped a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Scoped a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Scoped a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Scoped a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Scoped a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Scoped a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Scoped a -> a
foldr1 :: forall a. (a -> a -> a) -> Scoped a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Scoped a -> a
foldl1 :: forall a. (a -> a -> a) -> Scoped a -> a
$ctoList :: forall a. Scoped a -> [a]
toList :: forall a. Scoped a -> [a]
$cnull :: forall a. Scoped a -> Bool
null :: forall a. Scoped a -> Bool
$clength :: forall a. Scoped a -> Int
length :: forall a. Scoped a -> Int
$celem :: forall a. Eq a => a -> Scoped a -> Bool
elem :: forall a. Eq a => a -> Scoped a -> Bool
$cmaximum :: forall a. Ord a => Scoped a -> a
maximum :: forall a. Ord a => Scoped a -> a
$cminimum :: forall a. Ord a => Scoped a -> a
minimum :: forall a. Ord a => Scoped a -> a
$csum :: forall a. Num a => Scoped a -> a
sum :: forall a. Num a => Scoped a -> a
$cproduct :: forall a. Num a => Scoped a -> a
product :: forall a. Num a => Scoped a -> a
Foldable, Functor Scoped
Foldable Scoped
(Functor Scoped, Foldable Scoped) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Scoped a -> f (Scoped b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Scoped (f a) -> f (Scoped a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Scoped a -> m (Scoped b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Scoped (m a) -> m (Scoped a))
-> Traversable Scoped
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 => Scoped (m a) -> m (Scoped a)
forall (f :: * -> *) a.
Applicative f =>
Scoped (f a) -> f (Scoped a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Scoped a -> m (Scoped b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Scoped a -> f (Scoped b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Scoped a -> f (Scoped b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Scoped a -> f (Scoped b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Scoped (f a) -> f (Scoped a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Scoped (f a) -> f (Scoped a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Scoped a -> m (Scoped b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Scoped a -> m (Scoped b)
$csequence :: forall (m :: * -> *) a. Monad m => Scoped (m a) -> m (Scoped a)
sequence :: forall (m :: * -> *) a. Monad m => Scoped (m a) -> m (Scoped a)
Traversable, Int -> Scoped l -> ShowS
[Scoped l] -> ShowS
Scoped l -> String
(Int -> Scoped l -> ShowS)
-> (Scoped l -> String) -> ([Scoped l] -> ShowS) -> Show (Scoped l)
forall l. Show l => Int -> Scoped l -> ShowS
forall l. Show l => [Scoped l] -> ShowS
forall l. Show l => Scoped l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Scoped l -> ShowS
showsPrec :: Int -> Scoped l -> ShowS
$cshow :: forall l. Show l => Scoped l -> String
show :: Scoped l -> String
$cshowList :: forall l. Show l => [Scoped l] -> ShowS
showList :: [Scoped l] -> ShowS
Show, Typeable, Typeable (Scoped l)
Typeable (Scoped l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Scoped l -> c (Scoped l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Scoped l))
-> (Scoped l -> Constr)
-> (Scoped l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Scoped l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Scoped l)))
-> ((forall b. Data b => b -> b) -> Scoped l -> Scoped l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Scoped l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Scoped l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Scoped l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Scoped l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l))
-> Data (Scoped l)
Scoped l -> Constr
Scoped l -> DataType
(forall b. Data b => b -> b) -> Scoped l -> Scoped l
forall l. Data l => Typeable (Scoped l)
forall l. Data l => Scoped l -> Constr
forall l. Data l => Scoped l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Scoped l -> Scoped l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Scoped l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Scoped l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Scoped l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scoped l -> c (Scoped l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Scoped l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Scoped l))
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) -> Scoped l -> u
forall u. (forall d. Data d => d -> u) -> Scoped l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Scoped l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scoped l -> c (Scoped l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Scoped l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Scoped l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scoped l -> c (Scoped l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scoped l -> c (Scoped l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Scoped l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Scoped l)
$ctoConstr :: forall l. Data l => Scoped l -> Constr
toConstr :: Scoped l -> Constr
$cdataTypeOf :: forall l. Data l => Scoped l -> DataType
dataTypeOf :: Scoped l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Scoped l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Scoped l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Scoped l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Scoped l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Scoped l -> Scoped l
gmapT :: (forall b. Data b => b -> b) -> Scoped l -> Scoped l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scoped l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Scoped l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Scoped l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Scoped l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Scoped l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scoped l -> m (Scoped l)
Data, Scoped l -> Scoped l -> Bool
(Scoped l -> Scoped l -> Bool)
-> (Scoped l -> Scoped l -> Bool) -> Eq (Scoped l)
forall l. Eq l => Scoped l -> Scoped l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Scoped l -> Scoped l -> Bool
== :: Scoped l -> Scoped l -> Bool
$c/= :: forall l. Eq l => Scoped l -> Scoped l -> Bool
/= :: Scoped l -> Scoped l -> Bool
Eq, Eq (Scoped l)
Eq (Scoped l) =>
(Scoped l -> Scoped l -> Ordering)
-> (Scoped l -> Scoped l -> Bool)
-> (Scoped l -> Scoped l -> Bool)
-> (Scoped l -> Scoped l -> Bool)
-> (Scoped l -> Scoped l -> Bool)
-> (Scoped l -> Scoped l -> Scoped l)
-> (Scoped l -> Scoped l -> Scoped l)
-> Ord (Scoped l)
Scoped l -> Scoped l -> Bool
Scoped l -> Scoped l -> Ordering
Scoped l -> Scoped l -> Scoped l
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 l. Ord l => Eq (Scoped l)
forall l. Ord l => Scoped l -> Scoped l -> Bool
forall l. Ord l => Scoped l -> Scoped l -> Ordering
forall l. Ord l => Scoped l -> Scoped l -> Scoped l
$ccompare :: forall l. Ord l => Scoped l -> Scoped l -> Ordering
compare :: Scoped l -> Scoped l -> Ordering
$c< :: forall l. Ord l => Scoped l -> Scoped l -> Bool
< :: Scoped l -> Scoped l -> Bool
$c<= :: forall l. Ord l => Scoped l -> Scoped l -> Bool
<= :: Scoped l -> Scoped l -> Bool
$c> :: forall l. Ord l => Scoped l -> Scoped l -> Bool
> :: Scoped l -> Scoped l -> Bool
$c>= :: forall l. Ord l => Scoped l -> Scoped l -> Bool
>= :: Scoped l -> Scoped l -> Bool
$cmax :: forall l. Ord l => Scoped l -> Scoped l -> Scoped l
max :: Scoped l -> Scoped l -> Scoped l
$cmin :: forall l. Ord l => Scoped l -> Scoped l -> Scoped l
min :: Scoped l -> Scoped l -> Scoped l
Ord)

-- | Information about the names used in an AST.
data NameInfo l
    = GlobalSymbol Symbol (QName ())
      -- ^ global entitiy and the way it is referenced
    | LocalValue  SrcLoc
      -- ^ local value, and location where it is bound
    | TypeVar     SrcLoc
      -- ^ type variable, and location where it is bound
    | ValueBinder
      -- ^ here the value name is bound
    | TypeBinder 
      -- ^ here the type name is defined
    | Import      (Map (QName ()) [Symbol])
      -- ^ @import@ declaration, and the table of symbols that it
      -- introduces
    | ImportPart  [Symbol]
      -- ^ part of an @import@ declaration
    | Export      [Symbol]
      -- ^ part of an @export@ declaration
    | RecPatWildcard [Symbol]
      -- ^ wildcard in a record pattern. The list contains resolved names
      -- of the fields that are brought in scope by this pattern.
    | RecExpWildcard [(Symbol, NameInfo l)]
      -- ^ wildcard in a record construction expression. The list contains
      -- resolved names of the fields and information about values
      -- assigned to those fields.
    | None
      -- ^ no annotation
    | ScopeError  (Error l)
      -- ^ scope error
    deriving ((forall a b. (a -> b) -> NameInfo a -> NameInfo b)
-> (forall a b. a -> NameInfo b -> NameInfo a) -> Functor NameInfo
forall a b. a -> NameInfo b -> NameInfo a
forall a b. (a -> b) -> NameInfo a -> NameInfo 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) -> NameInfo a -> NameInfo b
fmap :: forall a b. (a -> b) -> NameInfo a -> NameInfo b
$c<$ :: forall a b. a -> NameInfo b -> NameInfo a
<$ :: forall a b. a -> NameInfo b -> NameInfo a
Functor, (forall m. Monoid m => NameInfo m -> m)
-> (forall m a. Monoid m => (a -> m) -> NameInfo a -> m)
-> (forall m a. Monoid m => (a -> m) -> NameInfo a -> m)
-> (forall a b. (a -> b -> b) -> b -> NameInfo a -> b)
-> (forall a b. (a -> b -> b) -> b -> NameInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> NameInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> NameInfo a -> b)
-> (forall a. (a -> a -> a) -> NameInfo a -> a)
-> (forall a. (a -> a -> a) -> NameInfo a -> a)
-> (forall a. NameInfo a -> [a])
-> (forall a. NameInfo a -> Bool)
-> (forall a. NameInfo a -> Int)
-> (forall a. Eq a => a -> NameInfo a -> Bool)
-> (forall a. Ord a => NameInfo a -> a)
-> (forall a. Ord a => NameInfo a -> a)
-> (forall a. Num a => NameInfo a -> a)
-> (forall a. Num a => NameInfo a -> a)
-> Foldable NameInfo
forall a. Eq a => a -> NameInfo a -> Bool
forall a. Num a => NameInfo a -> a
forall a. Ord a => NameInfo a -> a
forall m. Monoid m => NameInfo m -> m
forall a. NameInfo a -> Bool
forall a. NameInfo a -> Int
forall a. NameInfo a -> [a]
forall a. (a -> a -> a) -> NameInfo a -> a
forall m a. Monoid m => (a -> m) -> NameInfo a -> m
forall b a. (b -> a -> b) -> b -> NameInfo a -> b
forall a b. (a -> b -> b) -> b -> NameInfo 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 => NameInfo m -> m
fold :: forall m. Monoid m => NameInfo m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NameInfo a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NameInfo a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NameInfo a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NameInfo a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> NameInfo a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NameInfo a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NameInfo a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NameInfo a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NameInfo a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NameInfo a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NameInfo a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NameInfo a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> NameInfo a -> a
foldr1 :: forall a. (a -> a -> a) -> NameInfo a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NameInfo a -> a
foldl1 :: forall a. (a -> a -> a) -> NameInfo a -> a
$ctoList :: forall a. NameInfo a -> [a]
toList :: forall a. NameInfo a -> [a]
$cnull :: forall a. NameInfo a -> Bool
null :: forall a. NameInfo a -> Bool
$clength :: forall a. NameInfo a -> Int
length :: forall a. NameInfo a -> Int
$celem :: forall a. Eq a => a -> NameInfo a -> Bool
elem :: forall a. Eq a => a -> NameInfo a -> Bool
$cmaximum :: forall a. Ord a => NameInfo a -> a
maximum :: forall a. Ord a => NameInfo a -> a
$cminimum :: forall a. Ord a => NameInfo a -> a
minimum :: forall a. Ord a => NameInfo a -> a
$csum :: forall a. Num a => NameInfo a -> a
sum :: forall a. Num a => NameInfo a -> a
$cproduct :: forall a. Num a => NameInfo a -> a
product :: forall a. Num a => NameInfo a -> a
Foldable, Functor NameInfo
Foldable NameInfo
(Functor NameInfo, Foldable NameInfo) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NameInfo a -> f (NameInfo b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NameInfo (f a) -> f (NameInfo a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NameInfo a -> m (NameInfo b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NameInfo (m a) -> m (NameInfo a))
-> Traversable NameInfo
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 => NameInfo (m a) -> m (NameInfo a)
forall (f :: * -> *) a.
Applicative f =>
NameInfo (f a) -> f (NameInfo a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NameInfo a -> m (NameInfo b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NameInfo a -> f (NameInfo b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NameInfo a -> f (NameInfo b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NameInfo a -> f (NameInfo b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NameInfo (f a) -> f (NameInfo a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NameInfo (f a) -> f (NameInfo a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NameInfo a -> m (NameInfo b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NameInfo a -> m (NameInfo b)
$csequence :: forall (m :: * -> *) a. Monad m => NameInfo (m a) -> m (NameInfo a)
sequence :: forall (m :: * -> *) a. Monad m => NameInfo (m a) -> m (NameInfo a)
Traversable, Int -> NameInfo l -> ShowS
[NameInfo l] -> ShowS
NameInfo l -> String
(Int -> NameInfo l -> ShowS)
-> (NameInfo l -> String)
-> ([NameInfo l] -> ShowS)
-> Show (NameInfo l)
forall l. Show l => Int -> NameInfo l -> ShowS
forall l. Show l => [NameInfo l] -> ShowS
forall l. Show l => NameInfo l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> NameInfo l -> ShowS
showsPrec :: Int -> NameInfo l -> ShowS
$cshow :: forall l. Show l => NameInfo l -> String
show :: NameInfo l -> String
$cshowList :: forall l. Show l => [NameInfo l] -> ShowS
showList :: [NameInfo l] -> ShowS
Show, Typeable, Typeable (NameInfo l)
Typeable (NameInfo l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NameInfo l -> c (NameInfo l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NameInfo l))
-> (NameInfo l -> Constr)
-> (NameInfo l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NameInfo l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NameInfo l)))
-> ((forall b. Data b => b -> b) -> NameInfo l -> NameInfo l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameInfo l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameInfo l -> r)
-> (forall u. (forall d. Data d => d -> u) -> NameInfo l -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NameInfo l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l))
-> Data (NameInfo l)
NameInfo l -> Constr
NameInfo l -> DataType
(forall b. Data b => b -> b) -> NameInfo l -> NameInfo l
forall l. Data l => Typeable (NameInfo l)
forall l. Data l => NameInfo l -> Constr
forall l. Data l => NameInfo l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> NameInfo l -> NameInfo l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> NameInfo l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> NameInfo l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NameInfo l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameInfo l -> c (NameInfo l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NameInfo l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NameInfo l))
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) -> NameInfo l -> u
forall u. (forall d. Data d => d -> u) -> NameInfo l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NameInfo l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameInfo l -> c (NameInfo l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NameInfo l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NameInfo l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameInfo l -> c (NameInfo l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameInfo l -> c (NameInfo l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NameInfo l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NameInfo l)
$ctoConstr :: forall l. Data l => NameInfo l -> Constr
toConstr :: NameInfo l -> Constr
$cdataTypeOf :: forall l. Data l => NameInfo l -> DataType
dataTypeOf :: NameInfo l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NameInfo l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NameInfo l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NameInfo l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NameInfo l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> NameInfo l -> NameInfo l
gmapT :: (forall b. Data b => b -> b) -> NameInfo l -> NameInfo l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameInfo l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> NameInfo l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NameInfo l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> NameInfo l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameInfo l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameInfo l -> m (NameInfo l)
Data, NameInfo l -> NameInfo l -> Bool
(NameInfo l -> NameInfo l -> Bool)
-> (NameInfo l -> NameInfo l -> Bool) -> Eq (NameInfo l)
forall l. Eq l => NameInfo l -> NameInfo l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => NameInfo l -> NameInfo l -> Bool
== :: NameInfo l -> NameInfo l -> Bool
$c/= :: forall l. Eq l => NameInfo l -> NameInfo l -> Bool
/= :: NameInfo l -> NameInfo l -> Bool
Eq, Eq (NameInfo l)
Eq (NameInfo l) =>
(NameInfo l -> NameInfo l -> Ordering)
-> (NameInfo l -> NameInfo l -> Bool)
-> (NameInfo l -> NameInfo l -> Bool)
-> (NameInfo l -> NameInfo l -> Bool)
-> (NameInfo l -> NameInfo l -> Bool)
-> (NameInfo l -> NameInfo l -> NameInfo l)
-> (NameInfo l -> NameInfo l -> NameInfo l)
-> Ord (NameInfo l)
NameInfo l -> NameInfo l -> Bool
NameInfo l -> NameInfo l -> Ordering
NameInfo l -> NameInfo l -> NameInfo l
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 l. Ord l => Eq (NameInfo l)
forall l. Ord l => NameInfo l -> NameInfo l -> Bool
forall l. Ord l => NameInfo l -> NameInfo l -> Ordering
forall l. Ord l => NameInfo l -> NameInfo l -> NameInfo l
$ccompare :: forall l. Ord l => NameInfo l -> NameInfo l -> Ordering
compare :: NameInfo l -> NameInfo l -> Ordering
$c< :: forall l. Ord l => NameInfo l -> NameInfo l -> Bool
< :: NameInfo l -> NameInfo l -> Bool
$c<= :: forall l. Ord l => NameInfo l -> NameInfo l -> Bool
<= :: NameInfo l -> NameInfo l -> Bool
$c> :: forall l. Ord l => NameInfo l -> NameInfo l -> Bool
> :: NameInfo l -> NameInfo l -> Bool
$c>= :: forall l. Ord l => NameInfo l -> NameInfo l -> Bool
>= :: NameInfo l -> NameInfo l -> Bool
$cmax :: forall l. Ord l => NameInfo l -> NameInfo l -> NameInfo l
max :: NameInfo l -> NameInfo l -> NameInfo l
$cmin :: forall l. Ord l => NameInfo l -> NameInfo l -> NameInfo l
min :: NameInfo l -> NameInfo l -> NameInfo l
Ord)

-- | Errors during name resolution.
data Error l
  = ENotInScope (QName l) -- FIXME annotate with namespace (types/values)
    -- ^ name is not in scope
  | EAmbiguous (QName l) [Symbol]
    -- ^ name is ambiguous
  | ETypeAsClass (QName l)
    -- ^ type is used where a type class is expected
  | EClassAsType (QName l)
    -- ^ type class is used where a type is expected
  | ENotExported
      (Maybe (Name l)) --
      (Name l)         --
      (ModuleName l)
    -- ^ Attempt to explicitly import a name which is not exported (or,
    -- possibly, does not even exist). For example:
    --
    -- >import Prelude(Bool(Right))
    --
    -- The fields are:
    --
    -- 1. optional parent in the import list, e.g. @Bool@ in @Bool(Right)@
    --
    -- 2. the name which is not exported
    --
    -- 3. the module which does not export the name
  | EModNotFound (ModuleName l)
    -- ^ module not found
  | EInternal String
    -- ^ internal error
  deriving (Typeable (Error l)
Typeable (Error l) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Error l -> c (Error l))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Error l))
-> (Error l -> Constr)
-> (Error l -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Error l)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Error l)))
-> ((forall b. Data b => b -> b) -> Error l -> Error l)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Error l -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Error l -> r)
-> (forall u. (forall d. Data d => d -> u) -> Error l -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Error l -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Error l -> m (Error l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Error l -> m (Error l))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Error l -> m (Error l))
-> Data (Error l)
Error l -> Constr
Error l -> DataType
(forall b. Data b => b -> b) -> Error l -> Error l
forall l. Data l => Typeable (Error l)
forall l. Data l => Error l -> Constr
forall l. Data l => Error l -> DataType
forall l.
Data l =>
(forall b. Data b => b -> b) -> Error l -> Error l
forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Error l -> u
forall l u.
Data l =>
(forall d. Data d => d -> u) -> Error l -> [u]
forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Error l)
forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error l -> c (Error l)
forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Error l))
forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Error l))
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) -> Error l -> u
forall u. (forall d. Data d => d -> u) -> Error l -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Error l)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error l -> c (Error l)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Error l))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Error l))
$cgfoldl :: forall l (c :: * -> *).
Data l =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error l -> c (Error l)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error l -> c (Error l)
$cgunfold :: forall l (c :: * -> *).
Data l =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Error l)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Error l)
$ctoConstr :: forall l. Data l => Error l -> Constr
toConstr :: Error l -> Constr
$cdataTypeOf :: forall l. Data l => Error l -> DataType
dataTypeOf :: Error l -> DataType
$cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Error l))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Error l))
$cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
(Data l, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Error l))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Error l))
$cgmapT :: forall l.
Data l =>
(forall b. Data b => b -> b) -> Error l -> Error l
gmapT :: (forall b. Data b => b -> b) -> Error l -> Error l
$cgmapQl :: forall l r r'.
Data l =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
$cgmapQr :: forall l r r'.
Data l =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Error l -> r
$cgmapQ :: forall l u.
Data l =>
(forall d. Data d => d -> u) -> Error l -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Error l -> [u]
$cgmapQi :: forall l u.
Data l =>
Int -> (forall d. Data d => d -> u) -> Error l -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Error l -> u
$cgmapM :: forall l (m :: * -> *).
(Data l, Monad m) =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
$cgmapMp :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
$cgmapMo :: forall l (m :: * -> *).
(Data l, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error l -> m (Error l)
Data, Typeable, Int -> Error l -> ShowS
[Error l] -> ShowS
Error l -> String
(Int -> Error l -> ShowS)
-> (Error l -> String) -> ([Error l] -> ShowS) -> Show (Error l)
forall l. Show l => Int -> Error l -> ShowS
forall l. Show l => [Error l] -> ShowS
forall l. Show l => Error l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall l. Show l => Int -> Error l -> ShowS
showsPrec :: Int -> Error l -> ShowS
$cshow :: forall l. Show l => Error l -> String
show :: Error l -> String
$cshowList :: forall l. Show l => [Error l] -> ShowS
showList :: [Error l] -> ShowS
Show, (forall a b. (a -> b) -> Error a -> Error b)
-> (forall a b. a -> Error b -> Error a) -> Functor Error
forall a b. a -> Error b -> Error a
forall a b. (a -> b) -> Error a -> Error 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) -> Error a -> Error b
fmap :: forall a b. (a -> b) -> Error a -> Error b
$c<$ :: forall a b. a -> Error b -> Error a
<$ :: forall a b. a -> Error b -> Error a
Functor, (forall m. Monoid m => Error m -> m)
-> (forall m a. Monoid m => (a -> m) -> Error a -> m)
-> (forall m a. Monoid m => (a -> m) -> Error a -> m)
-> (forall a b. (a -> b -> b) -> b -> Error a -> b)
-> (forall a b. (a -> b -> b) -> b -> Error a -> b)
-> (forall b a. (b -> a -> b) -> b -> Error a -> b)
-> (forall b a. (b -> a -> b) -> b -> Error a -> b)
-> (forall a. (a -> a -> a) -> Error a -> a)
-> (forall a. (a -> a -> a) -> Error a -> a)
-> (forall a. Error a -> [a])
-> (forall a. Error a -> Bool)
-> (forall a. Error a -> Int)
-> (forall a. Eq a => a -> Error a -> Bool)
-> (forall a. Ord a => Error a -> a)
-> (forall a. Ord a => Error a -> a)
-> (forall a. Num a => Error a -> a)
-> (forall a. Num a => Error a -> a)
-> Foldable Error
forall a. Eq a => a -> Error a -> Bool
forall a. Num a => Error a -> a
forall a. Ord a => Error a -> a
forall m. Monoid m => Error m -> m
forall a. Error a -> Bool
forall a. Error a -> Int
forall a. Error a -> [a]
forall a. (a -> a -> a) -> Error a -> a
forall m a. Monoid m => (a -> m) -> Error a -> m
forall b a. (b -> a -> b) -> b -> Error a -> b
forall a b. (a -> b -> b) -> b -> Error 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 => Error m -> m
fold :: forall m. Monoid m => Error m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Error a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Error a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Error a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Error a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Error a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Error a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Error a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Error a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Error a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Error a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Error a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Error a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Error a -> a
foldr1 :: forall a. (a -> a -> a) -> Error a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Error a -> a
foldl1 :: forall a. (a -> a -> a) -> Error a -> a
$ctoList :: forall a. Error a -> [a]
toList :: forall a. Error a -> [a]
$cnull :: forall a. Error a -> Bool
null :: forall a. Error a -> Bool
$clength :: forall a. Error a -> Int
length :: forall a. Error a -> Int
$celem :: forall a. Eq a => a -> Error a -> Bool
elem :: forall a. Eq a => a -> Error a -> Bool
$cmaximum :: forall a. Ord a => Error a -> a
maximum :: forall a. Ord a => Error a -> a
$cminimum :: forall a. Ord a => Error a -> a
minimum :: forall a. Ord a => Error a -> a
$csum :: forall a. Num a => Error a -> a
sum :: forall a. Num a => Error a -> a
$cproduct :: forall a. Num a => Error a -> a
product :: forall a. Num a => Error a -> a
Foldable, Functor Error
Foldable Error
(Functor Error, Foldable Error) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Error a -> f (Error b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Error (f a) -> f (Error a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Error a -> m (Error b))
-> (forall (m :: * -> *) a. Monad m => Error (m a) -> m (Error a))
-> Traversable Error
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 => Error (m a) -> m (Error a)
forall (f :: * -> *) a. Applicative f => Error (f a) -> f (Error a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Error a -> m (Error b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Error a -> f (Error b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Error a -> f (Error b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Error a -> f (Error b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Error (f a) -> f (Error a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Error (f a) -> f (Error a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Error a -> m (Error b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Error a -> m (Error b)
$csequence :: forall (m :: * -> *) a. Monad m => Error (m a) -> m (Error a)
sequence :: forall (m :: * -> *) a. Monad m => Error (m a) -> m (Error a)
Traversable, Error l -> Error l -> Bool
(Error l -> Error l -> Bool)
-> (Error l -> Error l -> Bool) -> Eq (Error l)
forall l. Eq l => Error l -> Error l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall l. Eq l => Error l -> Error l -> Bool
== :: Error l -> Error l -> Bool
$c/= :: forall l. Eq l => Error l -> Error l -> Bool
/= :: Error l -> Error l -> Bool
Eq, Eq (Error l)
Eq (Error l) =>
(Error l -> Error l -> Ordering)
-> (Error l -> Error l -> Bool)
-> (Error l -> Error l -> Bool)
-> (Error l -> Error l -> Bool)
-> (Error l -> Error l -> Bool)
-> (Error l -> Error l -> Error l)
-> (Error l -> Error l -> Error l)
-> Ord (Error l)
Error l -> Error l -> Bool
Error l -> Error l -> Ordering
Error l -> Error l -> Error l
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 l. Ord l => Eq (Error l)
forall l. Ord l => Error l -> Error l -> Bool
forall l. Ord l => Error l -> Error l -> Ordering
forall l. Ord l => Error l -> Error l -> Error l
$ccompare :: forall l. Ord l => Error l -> Error l -> Ordering
compare :: Error l -> Error l -> Ordering
$c< :: forall l. Ord l => Error l -> Error l -> Bool
< :: Error l -> Error l -> Bool
$c<= :: forall l. Ord l => Error l -> Error l -> Bool
<= :: Error l -> Error l -> Bool
$c> :: forall l. Ord l => Error l -> Error l -> Bool
> :: Error l -> Error l -> Bool
$c>= :: forall l. Ord l => Error l -> Error l -> Bool
>= :: Error l -> Error l -> Bool
$cmax :: forall l. Ord l => Error l -> Error l -> Error l
max :: Error l -> Error l -> Error l
$cmin :: forall l. Ord l => Error l -> Error l -> Error l
min :: Error l -> Error l -> Error l
Ord)

-- | Pretty print a symbol.
ppSymbol :: Symbol -> String
ppSymbol :: Symbol -> String
ppSymbol Symbol
symbol = ModuleName () -> String
forall a. Pretty a => a -> String
prettyPrint (Symbol -> ModuleName ()
symbolModule Symbol
symbol) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"." String -> ShowS
forall a. [a] -> [a] -> [a]
++ Name () -> String
forall a. Pretty a => a -> String
prettyPrint (Symbol -> Name ()
symbolName Symbol
symbol)

-- | Display an error.
--
-- Note: can span multiple lines; the trailing newline is included.
ppError :: SrcInfo l => Error l -> String
ppError :: forall l. SrcInfo l => Error l -> String
ppError Error l
e =
  case Error l
e of
    ENotInScope QName l
qn -> String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"%s: not in scope: %s\n"
      (QName l -> String
forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc QName l
qn)
      (QName l -> String
forall a. Pretty a => a -> String
prettyPrint QName l
qn)
    EAmbiguous QName l
qn [Symbol]
names ->
      String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"%s: ambiguous name %s\nIt may refer to:\n"
        (QName l -> String
forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc QName l
qn)
        (QName l -> String
forall a. Pretty a => a -> String
prettyPrint QName l
qn)
      String -> ShowS
forall a. [a] -> [a] -> [a]
++
        [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
F.concat ((Symbol -> String) -> [Symbol] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String -> ShowS
forall r. PrintfType r => String -> r
printf String
"  %s\n" ShowS -> (Symbol -> String) -> Symbol -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> String
ppSymbol) [Symbol]
names)
    ETypeAsClass QName l
qn ->
      String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"%s: type %s is used where a class is expected\n"
        (QName l -> String
forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc QName l
qn)
        (QName l -> String
forall a. Pretty a => a -> String
prettyPrint QName l
qn)
    EClassAsType QName l
qn ->
      String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"%s: class %s is used where a type is expected\n"
        (QName l -> String
forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc QName l
qn)
        (QName l -> String
forall a. Pretty a => a -> String
prettyPrint QName l
qn)
    ENotExported Maybe (Name l)
_mbParent Name l
name ModuleName l
mod ->
      String -> String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"%s: %s does not export %s\n"
        (Name l -> String
forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc Name l
name)
        (ModuleName l -> String
forall a. Pretty a => a -> String
prettyPrint ModuleName l
mod)
        (Name l -> String
forall a. Pretty a => a -> String
prettyPrint Name l
name)
        -- FIXME: make use of mbParent
    EModNotFound ModuleName l
mod ->
      String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"%s: module not found: %s\n"
        (ModuleName l -> String
forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc ModuleName l
mod)
        (ModuleName l -> String
forall a. Pretty a => a -> String
prettyPrint ModuleName l
mod)
    EInternal String
s -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"Internal error: %s\n" String
s

  where
    ppLoc :: (Annotated a, SrcInfo l) => a l -> String
    ppLoc :: forall (a :: * -> *) l. (Annotated a, SrcInfo l) => a l -> String
ppLoc = SrcLoc -> String
forall a. Pretty a => a -> String
prettyPrint (SrcLoc -> String) -> (a l -> SrcLoc) -> a l -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. l -> SrcLoc
forall si. SrcInfo si => si -> SrcLoc
getPointLoc (l -> SrcLoc) -> (a l -> l) -> a l -> SrcLoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a l -> l
forall l. a l -> l
forall (ast :: * -> *) l. Annotated ast => ast l -> l
ann

instance (SrcInfo l) => SrcInfo (Scoped l) where
    toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> Scoped l
toSrcInfo SrcLoc
l1 [SrcSpan]
ss SrcLoc
l2 = NameInfo l -> l -> Scoped l
forall l. NameInfo l -> l -> Scoped l
Scoped NameInfo l
forall l. NameInfo l
None (l -> Scoped l) -> l -> Scoped l
forall a b. (a -> b) -> a -> b
$ SrcLoc -> [SrcSpan] -> SrcLoc -> l
forall si. SrcInfo si => SrcLoc -> [SrcSpan] -> SrcLoc -> si
toSrcInfo SrcLoc
l1 [SrcSpan]
ss SrcLoc
l2
    fromSrcInfo :: SrcSpanInfo -> Scoped l
fromSrcInfo = NameInfo l -> l -> Scoped l
forall l. NameInfo l -> l -> Scoped l
Scoped NameInfo l
forall l. NameInfo l
None (l -> Scoped l) -> (SrcSpanInfo -> l) -> SrcSpanInfo -> Scoped l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SrcSpanInfo -> l
forall si. SrcInfo si => SrcSpanInfo -> si
fromSrcInfo
    getPointLoc :: Scoped l -> SrcLoc
getPointLoc = l -> SrcLoc
forall si. SrcInfo si => si -> SrcLoc
getPointLoc (l -> SrcLoc) -> (Scoped l -> l) -> Scoped l -> SrcLoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scoped l -> l
forall l. Scoped l -> l
sLoc
    fileName :: Scoped l -> String
fileName = l -> String
forall si. SrcInfo si => si -> String
fileName (l -> String) -> (Scoped l -> l) -> Scoped l -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scoped l -> l
forall l. Scoped l -> l
sLoc
    startLine :: Scoped l -> Int
startLine = l -> Int
forall si. SrcInfo si => si -> Int
startLine (l -> Int) -> (Scoped l -> l) -> Scoped l -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scoped l -> l
forall l. Scoped l -> l
sLoc
    startColumn :: Scoped l -> Int
startColumn = l -> Int
forall si. SrcInfo si => si -> Int
startColumn (l -> Int) -> (Scoped l -> l) -> Scoped l -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scoped l -> l
forall l. Scoped l -> l
sLoc

sLoc :: Scoped l -> l
sLoc :: forall l. Scoped l -> l
sLoc (Scoped NameInfo l
_ l
l) = l
l