{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE UndecidableInstances       #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE ConstraintKinds            #-}
{-# LANGUAGE DerivingVia                #-}
{-# LANGUAGE DeriveTraversable          #-}

{-# OPTIONS_GHC -Wno-orphans #-}

-- | This module contains types to represent refined data types.

module Language.Haskell.Liquid.Types.DataDecl (

  -- * Parse-time entities describing refined data types
    DataDecl
  , DataDeclLHName
  , DataDeclParsed
  , DataDeclP (..)
  , DataName (..), dataNameSymbol
  , DataCtor
  , DataCtorParsed
  , DataCtorP (..)
  , DataConP (..)
  , HasDataDecl (..), hasDecl
  , DataDeclKind (..)
  , TyConP   (..)

  )
  where

import qualified Liquid.GHC.API as Ghc
import           GHC.Generics
import           Prelude                          hiding  (error)

import           Control.DeepSeq
import           Data.Typeable                          (Typeable)
import           Data.Generics                          (Data)
import qualified Data.Binary                            as B
import           Data.Hashable
import           Text.PrettyPrint.HughesPJ              hiding (first, (<>))
import           Text.Printf

import qualified Language.Fixpoint.Types as F

import           Language.Haskell.Liquid.GHC.Misc
import           Language.Haskell.Liquid.Types.Names
import           Language.Haskell.Liquid.Types.RType


--------------------------------------------------------------------------------
-- | Data type refinements
--------------------------------------------------------------------------------
type DataDecl = DataDeclP F.Symbol BareType
type DataDeclParsed = DataDeclP F.LocSymbol BareTypeParsed
type DataDeclLHName = DataDeclP LHName BareTypeLHName
data DataDeclP v ty  = DataDecl
  { forall v ty. DataDeclP v ty -> DataName
tycName   :: DataName              -- ^ Type  Constructor Name
  , forall v ty. DataDeclP v ty -> [Symbol]
tycTyVars :: [F.Symbol]            -- ^ Tyvar Parameters
  , forall v ty. DataDeclP v ty -> [PVarV v (BSortV v)]
tycPVars  :: [PVarV v (BSortV v)]  -- ^ PVar  Parameters
  , forall v ty. DataDeclP v ty -> Maybe [DataCtorP ty]
tycDCons  :: Maybe [DataCtorP ty]  -- ^ Data Constructors (Nothing is reserved for non-GADT style empty data declarations)
  , forall v ty. DataDeclP v ty -> SourcePos
tycSrcPos :: !F.SourcePos          -- ^ Source Position
  , forall v ty. DataDeclP v ty -> Maybe (SizeFunV v)
tycSFun   :: Maybe (SizeFunV v)    -- ^ Default termination measure
  , forall v ty. DataDeclP v ty -> Maybe ty
tycPropTy :: Maybe ty              -- ^ Type of Ind-Prop
  , forall v ty. DataDeclP v ty -> DataDeclKind
tycKind   :: !DataDeclKind         -- ^ User-defined or Auto-lifted
  } deriving (Typeable (DataDeclP v ty)
Typeable (DataDeclP v ty) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataDeclP v ty -> c (DataDeclP v ty))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataDeclP v ty))
-> (DataDeclP v ty -> Constr)
-> (DataDeclP v ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataDeclP v ty)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataDeclP v ty)))
-> ((forall b. Data b => b -> b)
    -> DataDeclP v ty -> DataDeclP v ty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DataDeclP v ty -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataDeclP v ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DataDeclP v ty -> m (DataDeclP v ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DataDeclP v ty -> m (DataDeclP v ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DataDeclP v ty -> m (DataDeclP v ty))
-> Data (DataDeclP v ty)
DataDeclP v ty -> Constr
DataDeclP v ty -> DataType
(forall b. Data b => b -> b) -> DataDeclP v ty -> DataDeclP v ty
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) -> DataDeclP v ty -> u
forall u. (forall d. Data d => d -> u) -> DataDeclP v ty -> [u]
forall v ty. (Data v, Data ty) => Typeable (DataDeclP v ty)
forall v ty. (Data v, Data ty) => DataDeclP v ty -> Constr
forall v ty. (Data v, Data ty) => DataDeclP v ty -> DataType
forall v ty.
(Data v, Data ty) =>
(forall b. Data b => b -> b) -> DataDeclP v ty -> DataDeclP v ty
forall v ty u.
(Data v, Data ty) =>
Int -> (forall d. Data d => d -> u) -> DataDeclP v ty -> u
forall v ty u.
(Data v, Data ty) =>
(forall d. Data d => d -> u) -> DataDeclP v ty -> [u]
forall v ty r r'.
(Data v, Data ty) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
forall v ty r r'.
(Data v, Data ty) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
forall v ty (m :: * -> *).
(Data v, Data ty, Monad m) =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
forall v ty (m :: * -> *).
(Data v, Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
forall v ty (c :: * -> *).
(Data v, Data ty) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataDeclP v ty)
forall v ty (c :: * -> *).
(Data v, Data ty) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclP v ty -> c (DataDeclP v ty)
forall v ty (t :: * -> *) (c :: * -> *).
(Data v, Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataDeclP v ty))
forall v ty (t :: * -> * -> *) (c :: * -> *).
(Data v, Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataDeclP v ty))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataDeclP v ty)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclP v ty -> c (DataDeclP v ty)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataDeclP v ty))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataDeclP v ty))
$cgfoldl :: forall v ty (c :: * -> *).
(Data v, Data ty) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclP v ty -> c (DataDeclP v ty)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclP v ty -> c (DataDeclP v ty)
$cgunfold :: forall v ty (c :: * -> *).
(Data v, Data ty) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataDeclP v ty)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataDeclP v ty)
$ctoConstr :: forall v ty. (Data v, Data ty) => DataDeclP v ty -> Constr
toConstr :: DataDeclP v ty -> Constr
$cdataTypeOf :: forall v ty. (Data v, Data ty) => DataDeclP v ty -> DataType
dataTypeOf :: DataDeclP v ty -> DataType
$cdataCast1 :: forall v ty (t :: * -> *) (c :: * -> *).
(Data v, Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataDeclP v ty))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataDeclP v ty))
$cdataCast2 :: forall v ty (t :: * -> * -> *) (c :: * -> *).
(Data v, Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataDeclP v ty))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataDeclP v ty))
$cgmapT :: forall v ty.
(Data v, Data ty) =>
(forall b. Data b => b -> b) -> DataDeclP v ty -> DataDeclP v ty
gmapT :: (forall b. Data b => b -> b) -> DataDeclP v ty -> DataDeclP v ty
$cgmapQl :: forall v ty r r'.
(Data v, Data ty) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
$cgmapQr :: forall v ty r r'.
(Data v, Data ty) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclP v ty -> r
$cgmapQ :: forall v ty u.
(Data v, Data ty) =>
(forall d. Data d => d -> u) -> DataDeclP v ty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataDeclP v ty -> [u]
$cgmapQi :: forall v ty u.
(Data v, Data ty) =>
Int -> (forall d. Data d => d -> u) -> DataDeclP v ty -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DataDeclP v ty -> u
$cgmapM :: forall v ty (m :: * -> *).
(Data v, Data ty, Monad m) =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
$cgmapMp :: forall v ty (m :: * -> *).
(Data v, Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
$cgmapMo :: forall v ty (m :: * -> *).
(Data v, Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataDeclP v ty -> m (DataDeclP v ty)
Data, Typeable, (forall x. DataDeclP v ty -> Rep (DataDeclP v ty) x)
-> (forall x. Rep (DataDeclP v ty) x -> DataDeclP v ty)
-> Generic (DataDeclP v ty)
forall x. Rep (DataDeclP v ty) x -> DataDeclP v ty
forall x. DataDeclP v ty -> Rep (DataDeclP v ty) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v ty x. Rep (DataDeclP v ty) x -> DataDeclP v ty
forall v ty x. DataDeclP v ty -> Rep (DataDeclP v ty) x
$cfrom :: forall v ty x. DataDeclP v ty -> Rep (DataDeclP v ty) x
from :: forall x. DataDeclP v ty -> Rep (DataDeclP v ty) x
$cto :: forall v ty x. Rep (DataDeclP v ty) x -> DataDeclP v ty
to :: forall x. Rep (DataDeclP v ty) x -> DataDeclP v ty
Generic, (forall a b. (a -> b) -> DataDeclP v a -> DataDeclP v b)
-> (forall a b. a -> DataDeclP v b -> DataDeclP v a)
-> Functor (DataDeclP v)
forall a b. a -> DataDeclP v b -> DataDeclP v a
forall a b. (a -> b) -> DataDeclP v a -> DataDeclP v b
forall v a b. a -> DataDeclP v b -> DataDeclP v a
forall v a b. (a -> b) -> DataDeclP v a -> DataDeclP v b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall v a b. (a -> b) -> DataDeclP v a -> DataDeclP v b
fmap :: forall a b. (a -> b) -> DataDeclP v a -> DataDeclP v b
$c<$ :: forall v a b. a -> DataDeclP v b -> DataDeclP v a
<$ :: forall a b. a -> DataDeclP v b -> DataDeclP v a
Functor, (forall m. Monoid m => DataDeclP v m -> m)
-> (forall m a. Monoid m => (a -> m) -> DataDeclP v a -> m)
-> (forall m a. Monoid m => (a -> m) -> DataDeclP v a -> m)
-> (forall a b. (a -> b -> b) -> b -> DataDeclP v a -> b)
-> (forall a b. (a -> b -> b) -> b -> DataDeclP v a -> b)
-> (forall b a. (b -> a -> b) -> b -> DataDeclP v a -> b)
-> (forall b a. (b -> a -> b) -> b -> DataDeclP v a -> b)
-> (forall a. (a -> a -> a) -> DataDeclP v a -> a)
-> (forall a. (a -> a -> a) -> DataDeclP v a -> a)
-> (forall a. DataDeclP v a -> [a])
-> (forall a. DataDeclP v a -> Bool)
-> (forall a. DataDeclP v a -> Int)
-> (forall a. Eq a => a -> DataDeclP v a -> Bool)
-> (forall a. Ord a => DataDeclP v a -> a)
-> (forall a. Ord a => DataDeclP v a -> a)
-> (forall a. Num a => DataDeclP v a -> a)
-> (forall a. Num a => DataDeclP v a -> a)
-> Foldable (DataDeclP v)
forall a. Eq a => a -> DataDeclP v a -> Bool
forall a. Num a => DataDeclP v a -> a
forall a. Ord a => DataDeclP v a -> a
forall m. Monoid m => DataDeclP v m -> m
forall a. DataDeclP v a -> Bool
forall a. DataDeclP v a -> Int
forall a. DataDeclP v a -> [a]
forall a. (a -> a -> a) -> DataDeclP v a -> a
forall v a. Eq a => a -> DataDeclP v a -> Bool
forall v a. Num a => DataDeclP v a -> a
forall v a. Ord a => DataDeclP v a -> a
forall v m. Monoid m => DataDeclP v m -> m
forall m a. Monoid m => (a -> m) -> DataDeclP v a -> m
forall v a. DataDeclP v a -> Bool
forall v a. DataDeclP v a -> Int
forall v a. DataDeclP v a -> [a]
forall b a. (b -> a -> b) -> b -> DataDeclP v a -> b
forall a b. (a -> b -> b) -> b -> DataDeclP v a -> b
forall v a. (a -> a -> a) -> DataDeclP v a -> a
forall v m a. Monoid m => (a -> m) -> DataDeclP v a -> m
forall v b a. (b -> a -> b) -> b -> DataDeclP v a -> b
forall v a b. (a -> b -> b) -> b -> DataDeclP v 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 v m. Monoid m => DataDeclP v m -> m
fold :: forall m. Monoid m => DataDeclP v m -> m
$cfoldMap :: forall v m a. Monoid m => (a -> m) -> DataDeclP v a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DataDeclP v a -> m
$cfoldMap' :: forall v m a. Monoid m => (a -> m) -> DataDeclP v a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> DataDeclP v a -> m
$cfoldr :: forall v a b. (a -> b -> b) -> b -> DataDeclP v a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DataDeclP v a -> b
$cfoldr' :: forall v a b. (a -> b -> b) -> b -> DataDeclP v a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DataDeclP v a -> b
$cfoldl :: forall v b a. (b -> a -> b) -> b -> DataDeclP v a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DataDeclP v a -> b
$cfoldl' :: forall v b a. (b -> a -> b) -> b -> DataDeclP v a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> DataDeclP v a -> b
$cfoldr1 :: forall v a. (a -> a -> a) -> DataDeclP v a -> a
foldr1 :: forall a. (a -> a -> a) -> DataDeclP v a -> a
$cfoldl1 :: forall v a. (a -> a -> a) -> DataDeclP v a -> a
foldl1 :: forall a. (a -> a -> a) -> DataDeclP v a -> a
$ctoList :: forall v a. DataDeclP v a -> [a]
toList :: forall a. DataDeclP v a -> [a]
$cnull :: forall v a. DataDeclP v a -> Bool
null :: forall a. DataDeclP v a -> Bool
$clength :: forall v a. DataDeclP v a -> Int
length :: forall a. DataDeclP v a -> Int
$celem :: forall v a. Eq a => a -> DataDeclP v a -> Bool
elem :: forall a. Eq a => a -> DataDeclP v a -> Bool
$cmaximum :: forall v a. Ord a => DataDeclP v a -> a
maximum :: forall a. Ord a => DataDeclP v a -> a
$cminimum :: forall v a. Ord a => DataDeclP v a -> a
minimum :: forall a. Ord a => DataDeclP v a -> a
$csum :: forall v a. Num a => DataDeclP v a -> a
sum :: forall a. Num a => DataDeclP v a -> a
$cproduct :: forall v a. Num a => DataDeclP v a -> a
product :: forall a. Num a => DataDeclP v a -> a
Foldable, Functor (DataDeclP v)
Foldable (DataDeclP v)
(Functor (DataDeclP v), Foldable (DataDeclP v)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> DataDeclP v a -> f (DataDeclP v b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    DataDeclP v (f a) -> f (DataDeclP v a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DataDeclP v a -> m (DataDeclP v b))
-> (forall (m :: * -> *) a.
    Monad m =>
    DataDeclP v (m a) -> m (DataDeclP v a))
-> Traversable (DataDeclP v)
forall v. Functor (DataDeclP v)
forall v. Foldable (DataDeclP v)
forall v (m :: * -> *) a.
Monad m =>
DataDeclP v (m a) -> m (DataDeclP v a)
forall v (f :: * -> *) a.
Applicative f =>
DataDeclP v (f a) -> f (DataDeclP v a)
forall v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataDeclP v a -> m (DataDeclP v b)
forall v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataDeclP v a -> f (DataDeclP v 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 =>
DataDeclP v (m a) -> m (DataDeclP v a)
forall (f :: * -> *) a.
Applicative f =>
DataDeclP v (f a) -> f (DataDeclP v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataDeclP v a -> m (DataDeclP v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataDeclP v a -> f (DataDeclP v b)
$ctraverse :: forall v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataDeclP v a -> f (DataDeclP v b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataDeclP v a -> f (DataDeclP v b)
$csequenceA :: forall v (f :: * -> *) a.
Applicative f =>
DataDeclP v (f a) -> f (DataDeclP v a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataDeclP v (f a) -> f (DataDeclP v a)
$cmapM :: forall v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataDeclP v a -> m (DataDeclP v b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataDeclP v a -> m (DataDeclP v b)
$csequence :: forall v (m :: * -> *) a.
Monad m =>
DataDeclP v (m a) -> m (DataDeclP v a)
sequence :: forall (m :: * -> *) a.
Monad m =>
DataDeclP v (m a) -> m (DataDeclP v a)
Traversable)
  deriving (Get (DataDeclP v ty)
[DataDeclP v ty] -> Put
DataDeclP v ty -> Put
(DataDeclP v ty -> Put)
-> Get (DataDeclP v ty)
-> ([DataDeclP v ty] -> Put)
-> Binary (DataDeclP v ty)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall v ty. (Binary v, Binary ty) => Get (DataDeclP v ty)
forall v ty. (Binary v, Binary ty) => [DataDeclP v ty] -> Put
forall v ty. (Binary v, Binary ty) => DataDeclP v ty -> Put
$cput :: forall v ty. (Binary v, Binary ty) => DataDeclP v ty -> Put
put :: DataDeclP v ty -> Put
$cget :: forall v ty. (Binary v, Binary ty) => Get (DataDeclP v ty)
get :: Get (DataDeclP v ty)
$cputList :: forall v ty. (Binary v, Binary ty) => [DataDeclP v ty] -> Put
putList :: [DataDeclP v ty] -> Put
B.Binary, Eq (DataDeclP v ty)
Eq (DataDeclP v ty) =>
(Int -> DataDeclP v ty -> Int)
-> (DataDeclP v ty -> Int) -> Hashable (DataDeclP v ty)
Int -> DataDeclP v ty -> Int
DataDeclP v ty -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall v ty. (Hashable ty, Hashable v) => Eq (DataDeclP v ty)
forall v ty.
(Hashable ty, Hashable v) =>
Int -> DataDeclP v ty -> Int
forall v ty. (Hashable ty, Hashable v) => DataDeclP v ty -> Int
$chashWithSalt :: forall v ty.
(Hashable ty, Hashable v) =>
Int -> DataDeclP v ty -> Int
hashWithSalt :: Int -> DataDeclP v ty -> Int
$chash :: forall v ty. (Hashable ty, Hashable v) => DataDeclP v ty -> Int
hash :: DataDeclP v ty -> Int
Hashable) via Generically (DataDeclP v ty)

-- | The name of the `TyCon` corresponding to a `DataDecl`
data DataName
  = DnName !(F.Located LHName)         -- ^ for 'isVanillyAlgTyCon' we can directly use the `TyCon` name
  | DnCon  !(F.Located LHName)         -- ^ for 'FamInst' TyCon we save some `DataCon` name
  deriving (DataName -> DataName -> Bool
(DataName -> DataName -> Bool)
-> (DataName -> DataName -> Bool) -> Eq DataName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataName -> DataName -> Bool
== :: DataName -> DataName -> Bool
$c/= :: DataName -> DataName -> Bool
/= :: DataName -> DataName -> Bool
Eq, Eq DataName
Eq DataName =>
(DataName -> DataName -> Ordering)
-> (DataName -> DataName -> Bool)
-> (DataName -> DataName -> Bool)
-> (DataName -> DataName -> Bool)
-> (DataName -> DataName -> Bool)
-> (DataName -> DataName -> DataName)
-> (DataName -> DataName -> DataName)
-> Ord DataName
DataName -> DataName -> Bool
DataName -> DataName -> Ordering
DataName -> DataName -> DataName
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 :: DataName -> DataName -> Ordering
compare :: DataName -> DataName -> Ordering
$c< :: DataName -> DataName -> Bool
< :: DataName -> DataName -> Bool
$c<= :: DataName -> DataName -> Bool
<= :: DataName -> DataName -> Bool
$c> :: DataName -> DataName -> Bool
> :: DataName -> DataName -> Bool
$c>= :: DataName -> DataName -> Bool
>= :: DataName -> DataName -> Bool
$cmax :: DataName -> DataName -> DataName
max :: DataName -> DataName -> DataName
$cmin :: DataName -> DataName -> DataName
min :: DataName -> DataName -> DataName
Ord, Typeable DataName
Typeable DataName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataName -> c DataName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataName)
-> (DataName -> Constr)
-> (DataName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataName))
-> ((forall b. Data b => b -> b) -> DataName -> DataName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataName -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DataName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataName -> m DataName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataName -> m DataName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataName -> m DataName)
-> Data DataName
DataName -> Constr
DataName -> DataType
(forall b. Data b => b -> b) -> DataName -> DataName
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) -> DataName -> u
forall u. (forall d. Data d => d -> u) -> DataName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataName -> c DataName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataName -> c DataName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataName -> c DataName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataName
$ctoConstr :: DataName -> Constr
toConstr :: DataName -> Constr
$cdataTypeOf :: DataName -> DataType
dataTypeOf :: DataName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataName)
$cgmapT :: (forall b. Data b => b -> b) -> DataName -> DataName
gmapT :: (forall b. Data b => b -> b) -> DataName -> DataName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataName -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataName -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataName -> m DataName
Data, Typeable, (forall x. DataName -> Rep DataName x)
-> (forall x. Rep DataName x -> DataName) -> Generic DataName
forall x. Rep DataName x -> DataName
forall x. DataName -> Rep DataName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataName -> Rep DataName x
from :: forall x. DataName -> Rep DataName x
$cto :: forall x. Rep DataName x -> DataName
to :: forall x. Rep DataName x -> DataName
Generic)

instance Hashable DataName

-- | Data Constructor
type DataCtor = DataCtorP BareType
type DataCtorParsed = DataCtorP BareTypeParsed
data DataCtorP ty = DataCtor
  { forall ty. DataCtorP ty -> Located LHName
dcName   :: F.Located LHName       -- ^ DataCon name
  , forall ty. DataCtorP ty -> [Symbol]
dcTyVars :: [F.Symbol]             -- ^ Type parameters
  , forall ty. DataCtorP ty -> [ty]
dcTheta  :: [ty]                   -- ^ The GHC ThetaType corresponding to DataCon.dataConSig
  , forall ty. DataCtorP ty -> [(LHName, ty)]
dcFields :: [(LHName, ty)]       -- ^ field-name and field-Type pairs
  , forall ty. DataCtorP ty -> Maybe ty
dcResult :: Maybe ty               -- ^ Possible output (if in GADT form)
  } deriving (Typeable (DataCtorP ty)
Typeable (DataCtorP ty) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataCtorP ty -> c (DataCtorP ty))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataCtorP ty))
-> (DataCtorP ty -> Constr)
-> (DataCtorP ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataCtorP ty)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataCtorP ty)))
-> ((forall b. Data b => b -> b) -> DataCtorP ty -> DataCtorP ty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataCtorP ty -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataCtorP ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty))
-> Data (DataCtorP ty)
DataCtorP ty -> Constr
DataCtorP ty -> DataType
(forall b. Data b => b -> b) -> DataCtorP ty -> DataCtorP ty
forall ty. Data ty => Typeable (DataCtorP ty)
forall ty. Data ty => DataCtorP ty -> Constr
forall ty. Data ty => DataCtorP ty -> DataType
forall ty.
Data ty =>
(forall b. Data b => b -> b) -> DataCtorP ty -> DataCtorP ty
forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> DataCtorP ty -> u
forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> DataCtorP ty -> [u]
forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataCtorP ty)
forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCtorP ty -> c (DataCtorP ty)
forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataCtorP ty))
forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataCtorP ty))
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) -> DataCtorP ty -> u
forall u. (forall d. Data d => d -> u) -> DataCtorP ty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataCtorP ty)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCtorP ty -> c (DataCtorP ty)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataCtorP ty))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataCtorP ty))
$cgfoldl :: forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCtorP ty -> c (DataCtorP ty)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataCtorP ty -> c (DataCtorP ty)
$cgunfold :: forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataCtorP ty)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DataCtorP ty)
$ctoConstr :: forall ty. Data ty => DataCtorP ty -> Constr
toConstr :: DataCtorP ty -> Constr
$cdataTypeOf :: forall ty. Data ty => DataCtorP ty -> DataType
dataTypeOf :: DataCtorP ty -> DataType
$cdataCast1 :: forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DataCtorP ty))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DataCtorP ty))
$cdataCast2 :: forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataCtorP ty))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DataCtorP ty))
$cgmapT :: forall ty.
Data ty =>
(forall b. Data b => b -> b) -> DataCtorP ty -> DataCtorP ty
gmapT :: (forall b. Data b => b -> b) -> DataCtorP ty -> DataCtorP ty
$cgmapQl :: forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
$cgmapQr :: forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataCtorP ty -> r
$cgmapQ :: forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> DataCtorP ty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataCtorP ty -> [u]
$cgmapQi :: forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> DataCtorP ty -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataCtorP ty -> u
$cgmapM :: forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
$cgmapMp :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
$cgmapMo :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataCtorP ty -> m (DataCtorP ty)
Data, Typeable, (forall x. DataCtorP ty -> Rep (DataCtorP ty) x)
-> (forall x. Rep (DataCtorP ty) x -> DataCtorP ty)
-> Generic (DataCtorP ty)
forall x. Rep (DataCtorP ty) x -> DataCtorP ty
forall x. DataCtorP ty -> Rep (DataCtorP ty) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ty x. Rep (DataCtorP ty) x -> DataCtorP ty
forall ty x. DataCtorP ty -> Rep (DataCtorP ty) x
$cfrom :: forall ty x. DataCtorP ty -> Rep (DataCtorP ty) x
from :: forall x. DataCtorP ty -> Rep (DataCtorP ty) x
$cto :: forall ty x. Rep (DataCtorP ty) x -> DataCtorP ty
to :: forall x. Rep (DataCtorP ty) x -> DataCtorP ty
Generic, DataCtorP ty -> DataCtorP ty -> Bool
(DataCtorP ty -> DataCtorP ty -> Bool)
-> (DataCtorP ty -> DataCtorP ty -> Bool) -> Eq (DataCtorP ty)
forall ty. Eq ty => DataCtorP ty -> DataCtorP ty -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall ty. Eq ty => DataCtorP ty -> DataCtorP ty -> Bool
== :: DataCtorP ty -> DataCtorP ty -> Bool
$c/= :: forall ty. Eq ty => DataCtorP ty -> DataCtorP ty -> Bool
/= :: DataCtorP ty -> DataCtorP ty -> Bool
Eq, (forall a b. (a -> b) -> DataCtorP a -> DataCtorP b)
-> (forall a b. a -> DataCtorP b -> DataCtorP a)
-> Functor DataCtorP
forall a b. a -> DataCtorP b -> DataCtorP a
forall a b. (a -> b) -> DataCtorP a -> DataCtorP 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) -> DataCtorP a -> DataCtorP b
fmap :: forall a b. (a -> b) -> DataCtorP a -> DataCtorP b
$c<$ :: forall a b. a -> DataCtorP b -> DataCtorP a
<$ :: forall a b. a -> DataCtorP b -> DataCtorP a
Functor, (forall m. Monoid m => DataCtorP m -> m)
-> (forall m a. Monoid m => (a -> m) -> DataCtorP a -> m)
-> (forall m a. Monoid m => (a -> m) -> DataCtorP a -> m)
-> (forall a b. (a -> b -> b) -> b -> DataCtorP a -> b)
-> (forall a b. (a -> b -> b) -> b -> DataCtorP a -> b)
-> (forall b a. (b -> a -> b) -> b -> DataCtorP a -> b)
-> (forall b a. (b -> a -> b) -> b -> DataCtorP a -> b)
-> (forall a. (a -> a -> a) -> DataCtorP a -> a)
-> (forall a. (a -> a -> a) -> DataCtorP a -> a)
-> (forall ty. DataCtorP ty -> [ty])
-> (forall a. DataCtorP a -> Bool)
-> (forall a. DataCtorP a -> Int)
-> (forall a. Eq a => a -> DataCtorP a -> Bool)
-> (forall a. Ord a => DataCtorP a -> a)
-> (forall a. Ord a => DataCtorP a -> a)
-> (forall a. Num a => DataCtorP a -> a)
-> (forall a. Num a => DataCtorP a -> a)
-> Foldable DataCtorP
forall a. Eq a => a -> DataCtorP a -> Bool
forall a. Num a => DataCtorP a -> a
forall a. Ord a => DataCtorP a -> a
forall m. Monoid m => DataCtorP m -> m
forall a. DataCtorP a -> Bool
forall a. DataCtorP a -> Int
forall ty. DataCtorP ty -> [ty]
forall a. (a -> a -> a) -> DataCtorP a -> a
forall m a. Monoid m => (a -> m) -> DataCtorP a -> m
forall b a. (b -> a -> b) -> b -> DataCtorP a -> b
forall a b. (a -> b -> b) -> b -> DataCtorP 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 => DataCtorP m -> m
fold :: forall m. Monoid m => DataCtorP m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DataCtorP a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DataCtorP a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DataCtorP a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> DataCtorP a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> DataCtorP a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DataCtorP a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DataCtorP a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DataCtorP a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DataCtorP a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DataCtorP a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DataCtorP a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> DataCtorP a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> DataCtorP a -> a
foldr1 :: forall a. (a -> a -> a) -> DataCtorP a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DataCtorP a -> a
foldl1 :: forall a. (a -> a -> a) -> DataCtorP a -> a
$ctoList :: forall ty. DataCtorP ty -> [ty]
toList :: forall ty. DataCtorP ty -> [ty]
$cnull :: forall a. DataCtorP a -> Bool
null :: forall a. DataCtorP a -> Bool
$clength :: forall a. DataCtorP a -> Int
length :: forall a. DataCtorP a -> Int
$celem :: forall a. Eq a => a -> DataCtorP a -> Bool
elem :: forall a. Eq a => a -> DataCtorP a -> Bool
$cmaximum :: forall a. Ord a => DataCtorP a -> a
maximum :: forall a. Ord a => DataCtorP a -> a
$cminimum :: forall a. Ord a => DataCtorP a -> a
minimum :: forall a. Ord a => DataCtorP a -> a
$csum :: forall a. Num a => DataCtorP a -> a
sum :: forall a. Num a => DataCtorP a -> a
$cproduct :: forall a. Num a => DataCtorP a -> a
product :: forall a. Num a => DataCtorP a -> a
Foldable, Functor DataCtorP
Foldable DataCtorP
(Functor DataCtorP, Foldable DataCtorP) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> DataCtorP a -> f (DataCtorP b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    DataCtorP (f a) -> f (DataCtorP a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DataCtorP a -> m (DataCtorP b))
-> (forall (m :: * -> *) a.
    Monad m =>
    DataCtorP (m a) -> m (DataCtorP a))
-> Traversable DataCtorP
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 =>
DataCtorP (m a) -> m (DataCtorP a)
forall (f :: * -> *) a.
Applicative f =>
DataCtorP (f a) -> f (DataCtorP a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataCtorP a -> m (DataCtorP b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataCtorP a -> f (DataCtorP b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataCtorP a -> f (DataCtorP b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataCtorP a -> f (DataCtorP b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataCtorP (f a) -> f (DataCtorP a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataCtorP (f a) -> f (DataCtorP a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataCtorP a -> m (DataCtorP b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataCtorP a -> m (DataCtorP b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
DataCtorP (m a) -> m (DataCtorP a)
sequence :: forall (m :: * -> *) a.
Monad m =>
DataCtorP (m a) -> m (DataCtorP a)
Traversable)

instance Hashable ty => Hashable (DataCtorP ty)

-- | What kind of `DataDecl` is it?
data DataDeclKind
  = DataUser           -- ^ User defined data-definitions         (should have refined fields)
  | DataReflected      -- ^ Automatically lifted data-definitions (do not have refined fields)
  deriving (DataDeclKind -> DataDeclKind -> Bool
(DataDeclKind -> DataDeclKind -> Bool)
-> (DataDeclKind -> DataDeclKind -> Bool) -> Eq DataDeclKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataDeclKind -> DataDeclKind -> Bool
== :: DataDeclKind -> DataDeclKind -> Bool
$c/= :: DataDeclKind -> DataDeclKind -> Bool
/= :: DataDeclKind -> DataDeclKind -> Bool
Eq, Typeable DataDeclKind
Typeable DataDeclKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataDeclKind -> c DataDeclKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataDeclKind)
-> (DataDeclKind -> Constr)
-> (DataDeclKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataDeclKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DataDeclKind))
-> ((forall b. Data b => b -> b) -> DataDeclKind -> DataDeclKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataDeclKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataDeclKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind)
-> Data DataDeclKind
DataDeclKind -> Constr
DataDeclKind -> DataType
(forall b. Data b => b -> b) -> DataDeclKind -> DataDeclKind
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) -> DataDeclKind -> u
forall u. (forall d. Data d => d -> u) -> DataDeclKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDeclKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclKind -> c DataDeclKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDeclKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataDeclKind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclKind -> c DataDeclKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataDeclKind -> c DataDeclKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDeclKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataDeclKind
$ctoConstr :: DataDeclKind -> Constr
toConstr :: DataDeclKind -> Constr
$cdataTypeOf :: DataDeclKind -> DataType
dataTypeOf :: DataDeclKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDeclKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataDeclKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataDeclKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataDeclKind)
$cgmapT :: (forall b. Data b => b -> b) -> DataDeclKind -> DataDeclKind
gmapT :: (forall b. Data b => b -> b) -> DataDeclKind -> DataDeclKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataDeclKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataDeclKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataDeclKind -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDeclKind -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDeclKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataDeclKind -> m DataDeclKind
Data, Typeable, (forall x. DataDeclKind -> Rep DataDeclKind x)
-> (forall x. Rep DataDeclKind x -> DataDeclKind)
-> Generic DataDeclKind
forall x. Rep DataDeclKind x -> DataDeclKind
forall x. DataDeclKind -> Rep DataDeclKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataDeclKind -> Rep DataDeclKind x
from :: forall x. DataDeclKind -> Rep DataDeclKind x
$cto :: forall x. Rep DataDeclKind x -> DataDeclKind
to :: forall x. Rep DataDeclKind x -> DataDeclKind
Generic, Int -> DataDeclKind -> ShowS
[DataDeclKind] -> ShowS
DataDeclKind -> String
(Int -> DataDeclKind -> ShowS)
-> (DataDeclKind -> String)
-> ([DataDeclKind] -> ShowS)
-> Show DataDeclKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataDeclKind -> ShowS
showsPrec :: Int -> DataDeclKind -> ShowS
$cshow :: DataDeclKind -> String
show :: DataDeclKind -> String
$cshowList :: [DataDeclKind] -> ShowS
showList :: [DataDeclKind] -> ShowS
Show)
  deriving Eq DataDeclKind
Eq DataDeclKind =>
(Int -> DataDeclKind -> Int)
-> (DataDeclKind -> Int) -> Hashable DataDeclKind
Int -> DataDeclKind -> Int
DataDeclKind -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> DataDeclKind -> Int
hashWithSalt :: Int -> DataDeclKind -> Int
$chash :: DataDeclKind -> Int
hash :: DataDeclKind -> Int
Hashable via Generically DataDeclKind

data HasDataDecl
  = NoDecl  (Maybe SizeFun)
  | HasDecl
  deriving (Int -> HasDataDecl -> ShowS
[HasDataDecl] -> ShowS
HasDataDecl -> String
(Int -> HasDataDecl -> ShowS)
-> (HasDataDecl -> String)
-> ([HasDataDecl] -> ShowS)
-> Show HasDataDecl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HasDataDecl -> ShowS
showsPrec :: Int -> HasDataDecl -> ShowS
$cshow :: HasDataDecl -> String
show :: HasDataDecl -> String
$cshowList :: [HasDataDecl] -> ShowS
showList :: [HasDataDecl] -> ShowS
Show)

instance F.PPrint HasDataDecl where
  pprintTidy :: Tidy -> HasDataDecl -> Doc
pprintTidy Tidy
_ HasDataDecl
HasDecl    = String -> Doc
text String
"HasDecl"
  pprintTidy Tidy
k (NoDecl Maybe SizeFun
z) = String -> Doc
text String
"NoDecl" Doc -> Doc -> Doc
<+> Doc -> Doc
parens (Tidy -> Maybe SizeFun -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k Maybe SizeFun
z)

hasDecl :: DataDecl -> HasDataDecl
hasDecl :: DataDecl -> HasDataDecl
hasDecl DataDecl
d
  | Maybe [DataCtorP BareType] -> Bool
forall a. Maybe a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (DataDecl -> Maybe [DataCtorP BareType]
forall v ty. DataDeclP v ty -> Maybe [DataCtorP ty]
tycDCons DataDecl
d)
  = Maybe SizeFun -> HasDataDecl
NoDecl (DataDecl -> Maybe SizeFun
forall v ty. DataDeclP v ty -> Maybe (SizeFunV v)
tycSFun DataDecl
d)
  -- // | Just s <- tycSFun d, null (tycDCons d)
  -- // = NoDecl (Just s)
  | Bool
otherwise
  = HasDataDecl
HasDecl

instance NFData   DataDeclKind
instance B.Binary DataDeclKind
instance B.Binary DataName
instance B.Binary ty => B.Binary (DataCtorP ty)

instance Eq (DataDeclP v ty) where
  DataDeclP v ty
d1 == :: DataDeclP v ty -> DataDeclP v ty -> Bool
== DataDeclP v ty
d2 = DataDeclP v ty -> DataName
forall v ty. DataDeclP v ty -> DataName
tycName DataDeclP v ty
d1 DataName -> DataName -> Bool
forall a. Eq a => a -> a -> Bool
== DataDeclP v ty -> DataName
forall v ty. DataDeclP v ty -> DataName
tycName DataDeclP v ty
d2

instance Ord DataDecl where
  compare :: DataDecl -> DataDecl -> Ordering
compare DataDecl
d1 DataDecl
d2 = DataName -> DataName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (DataDecl -> DataName
forall v ty. DataDeclP v ty -> DataName
tycName DataDecl
d1) (DataDecl -> DataName
forall v ty. DataDeclP v ty -> DataName
tycName DataDecl
d2)

instance F.Loc (DataCtorP ty) where
  srcSpan :: DataCtorP ty -> SrcSpan
srcSpan = Located LHName -> SrcSpan
forall a. Loc a => a -> SrcSpan
F.srcSpan (Located LHName -> SrcSpan)
-> (DataCtorP ty -> Located LHName) -> DataCtorP ty -> SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataCtorP ty -> Located LHName
forall ty. DataCtorP ty -> Located LHName
dcName

instance F.Loc (DataDeclP v ty) where
  srcSpan :: DataDeclP v ty -> SrcSpan
srcSpan = SrcSpan -> SrcSpan
srcSpanFSrcSpan (SrcSpan -> SrcSpan)
-> (DataDeclP v ty -> SrcSpan) -> DataDeclP v ty -> SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourcePos -> SrcSpan
sourcePosSrcSpan (SourcePos -> SrcSpan)
-> (DataDeclP v ty -> SourcePos) -> DataDeclP v ty -> SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataDeclP v ty -> SourcePos
forall v ty. DataDeclP v ty -> SourcePos
tycSrcPos

instance F.Loc DataName where
  srcSpan :: DataName -> SrcSpan
srcSpan (DnName Located LHName
z) = Located LHName -> SrcSpan
forall a. Loc a => a -> SrcSpan
F.srcSpan Located LHName
z
  srcSpan (DnCon  Located LHName
z) = Located LHName -> SrcSpan
forall a. Loc a => a -> SrcSpan
F.srcSpan Located LHName
z


-- | For debugging.
instance (Show v, Show ty) => Show (DataDeclP v ty) where
  show :: DataDeclP v ty -> String
show DataDeclP v ty
dd = String -> String -> String -> String -> ShowS
forall r. PrintfType r => String -> r
printf String
"DataDecl: data = %s, tyvars = %s, sizeFun = %s, kind = %s" -- [at: %s]"
              (DataName -> String
forall a. Show a => a -> String
show (DataName -> String) -> DataName -> String
forall a b. (a -> b) -> a -> b
$ DataDeclP v ty -> DataName
forall v ty. DataDeclP v ty -> DataName
tycName   DataDeclP v ty
dd)
              ([Symbol] -> String
forall a. Show a => a -> String
show ([Symbol] -> String) -> [Symbol] -> String
forall a b. (a -> b) -> a -> b
$ DataDeclP v ty -> [Symbol]
forall v ty. DataDeclP v ty -> [Symbol]
tycTyVars DataDeclP v ty
dd)
              (Maybe (SizeFunV v) -> String
forall a. Show a => a -> String
show (Maybe (SizeFunV v) -> String) -> Maybe (SizeFunV v) -> String
forall a b. (a -> b) -> a -> b
$ DataDeclP v ty -> Maybe (SizeFunV v)
forall v ty. DataDeclP v ty -> Maybe (SizeFunV v)
tycSFun   DataDeclP v ty
dd)
              (DataDeclKind -> String
forall a. Show a => a -> String
show (DataDeclKind -> String) -> DataDeclKind -> String
forall a b. (a -> b) -> a -> b
$ DataDeclP v ty -> DataDeclKind
forall v ty. DataDeclP v ty -> DataDeclKind
tycKind   DataDeclP v ty
dd)


instance Show DataName where
  show :: DataName -> String
show (DnName Located LHName
n) =               LHName -> String
forall a. Show a => a -> String
show (Located LHName -> LHName
forall a. Located a -> a
F.val Located LHName
n)
  show (DnCon  Located LHName
c) = String
"datacon:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ LHName -> String
forall a. Show a => a -> String
show (Located LHName -> LHName
forall a. Located a -> a
F.val Located LHName
c)

instance F.PPrint DataName where
  pprintTidy :: Tidy -> DataName -> Doc
pprintTidy Tidy
k (DnName Located LHName
n) = Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
F.val Located LHName
n)
  pprintTidy Tidy
k (DnCon  Located LHName
n) = Tidy -> LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (Located LHName -> LHName
forall a. Located a -> a
F.val Located LHName
n)

  -- symbol (DnName z) = F.suffixSymbol "DnName" (F.val z)
  -- symbol (DnCon  z) = F.suffixSymbol "DnCon"  (F.val z)

dataNameSymbol :: DataName -> F.Located LHName
dataNameSymbol :: DataName -> Located LHName
dataNameSymbol (DnName Located LHName
z) = Located LHName
z
dataNameSymbol (DnCon  Located LHName
z) = Located LHName
z

-- TODO: just use Located instead of dc_loc, dc_locE
data DataConP = DataConP
  { DataConP -> SourcePos
dcpLoc        :: !F.SourcePos
  , DataConP -> DataCon
dcpCon        :: !Ghc.DataCon            -- ^ Corresponding GHC DataCon
  , DataConP -> [RTyVar]
dcpFreeTyVars :: ![RTyVar]               -- ^ Type parameters
  , DataConP -> [PVar RSort]
dcpFreePred   :: ![PVar RSort]           -- ^ Abstract Refinement parameters
  , DataConP -> [SpecType]
dcpTyConstrs  :: ![SpecType]             -- ^ ? Class constraints (via `dataConStupidTheta`)
  , DataConP -> [(LHName, SpecType)]
dcpTyArgs     :: ![(LHName, SpecType)] -- ^ Value parameters
  , DataConP -> SpecType
dcpTyRes      :: !SpecType               -- ^ Result type
  , DataConP -> Bool
dcpIsGadt     :: !Bool                   -- ^ Was this specified in GADT style (if so, DONT use function names as fields)
  , DataConP -> Symbol
dcpModule     :: !F.Symbol               -- ^ Which module was this defined in
  , DataConP -> SourcePos
dcpLocE       :: !F.SourcePos
  } deriving ((forall x. DataConP -> Rep DataConP x)
-> (forall x. Rep DataConP x -> DataConP) -> Generic DataConP
forall x. Rep DataConP x -> DataConP
forall x. DataConP -> Rep DataConP x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataConP -> Rep DataConP x
from :: forall x. DataConP -> Rep DataConP x
$cto :: forall x. Rep DataConP x -> DataConP
to :: forall x. Rep DataConP x -> DataConP
Generic, Typeable DataConP
Typeable DataConP =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataConP -> c DataConP)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataConP)
-> (DataConP -> Constr)
-> (DataConP -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataConP))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConP))
-> ((forall b. Data b => b -> b) -> DataConP -> DataConP)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConP -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataConP -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataConP -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DataConP -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataConP -> m DataConP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConP -> m DataConP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataConP -> m DataConP)
-> Data DataConP
DataConP -> Constr
DataConP -> DataType
(forall b. Data b => b -> b) -> DataConP -> DataConP
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) -> DataConP -> u
forall u. (forall d. Data d => d -> u) -> DataConP -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConP -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConP -> c DataConP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConP)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConP -> c DataConP
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataConP -> c DataConP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConP
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataConP
$ctoConstr :: DataConP -> Constr
toConstr :: DataConP -> Constr
$cdataTypeOf :: DataConP -> DataType
dataTypeOf :: DataConP -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConP)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataConP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConP)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataConP)
$cgmapT :: (forall b. Data b => b -> b) -> DataConP -> DataConP
gmapT :: (forall b. Data b => b -> b) -> DataConP -> DataConP
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConP -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataConP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConP -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataConP -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataConP -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataConP -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConP -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataConP -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataConP -> m DataConP
Data, Typeable)

-- | [NOTE:DataCon-Data] for each 'DataConP' we also
--   store the type of the constructed data. This is
--   *the same as* 'tyRes' for *vanilla* ADTs
--   (e.g. List, Maybe etc.) but may differ for GADTs.
--   For example,
--
--      data Thing a where
--        X  :: Thing Int
--        Y  :: Thing Bool
--
--   Here the 'DataConP' associated with 'X' (resp. 'Y')
--   has 'tyRes' corresponding to 'Thing Int' (resp. 'Thing Bool'),
--   but in both cases, the 'tyData' should be 'Thing a'.
--

instance F.Loc DataConP where
  srcSpan :: DataConP -> SrcSpan
srcSpan DataConP
d = SourcePos -> SourcePos -> SrcSpan
F.SS (DataConP -> SourcePos
dcpLoc DataConP
d) (DataConP -> SourcePos
dcpLocE DataConP
d)

instance (F.PPrint lname, F.PPrint ty) => F.PPrint (DataDeclP lname ty) where
  pprintTidy :: Tidy -> DataDeclP lname ty -> Doc
pprintTidy Tidy
k DataDeclP lname ty
dd =
    let
      prefix :: Doc
prefix = Doc
"data" Doc -> Doc -> Doc
<+> DataName -> Doc
forall a. PPrint a => a -> Doc
F.pprint (DataDeclP lname ty -> DataName
forall v ty. DataDeclP v ty -> DataName
tycName DataDeclP lname ty
dd) Doc -> Doc -> Doc
<+> Maybe (SizeFunV lname) -> Doc
forall v. PPrint v => Maybe (SizeFunV v) -> Doc
ppMbSizeFun (DataDeclP lname ty -> Maybe (SizeFunV lname)
forall v ty. DataDeclP v ty -> Maybe (SizeFunV v)
tycSFun DataDeclP lname ty
dd) Doc -> Doc -> Doc
<+> [Symbol] -> Doc
forall a. PPrint a => a -> Doc
F.pprint (DataDeclP lname ty -> [Symbol]
forall v ty. DataDeclP v ty -> [Symbol]
tycTyVars DataDeclP lname ty
dd)
    in
      case DataDeclP lname ty -> Maybe [DataCtorP ty]
forall v ty. DataDeclP v ty -> Maybe [DataCtorP ty]
tycDCons DataDeclP lname ty
dd of
        Maybe [DataCtorP ty]
Nothing   -> Doc
prefix
        Just [DataCtorP ty]
cons -> Doc
prefix Doc -> Doc -> Doc
<+> Doc
"=" Doc -> Doc -> Doc
$+$ Int -> Doc -> Doc
nest Int
4 ([Doc] -> Doc
vcat ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ [ Doc
"|" Doc -> Doc -> Doc
<+> Tidy -> DataCtorP ty -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k DataCtorP ty
c | DataCtorP ty
c <- [DataCtorP ty]
cons ])

instance F.PPrint ty => F.PPrint (DataCtorP ty) where
  pprintTidy :: Tidy -> DataCtorP ty -> Doc
pprintTidy Tidy
k (DataCtor Located LHName
c [Symbol]
as [ty]
ths [(LHName, ty)]
xts Maybe ty
t) = Tidy -> Located LHName -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k Located LHName
c Doc -> Doc -> Doc
<+> String -> Doc
text String
"::" Doc -> Doc -> Doc
<+> Tidy -> [Symbol] -> Doc
forall a. PPrint a => Tidy -> [a] -> Doc
ppVars Tidy
k [Symbol]
as Doc -> Doc -> Doc
<+> [ty] -> Doc
forall {a}. PPrint a => [a] -> Doc
ppThetas [ty]
ths Doc -> Doc -> Doc
<+> Tidy -> Doc -> [(LHName, ty)] -> Doc
forall k v. (PPrint k, PPrint v) => Tidy -> Doc -> [(k, v)] -> Doc
ppFields Tidy
k Doc
" ->" [(LHName, ty)]
xts Doc -> Doc -> Doc
<+> Doc
"->" Doc -> Doc -> Doc
<+> Doc
res
    where
      res :: Doc
res         = Doc -> (ty -> Doc) -> Maybe ty -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
"*" (Tidy -> ty -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k) Maybe ty
t
      ppThetas :: [a] -> Doc
ppThetas [] = Doc
empty
      ppThetas [a]
ts = Doc -> Doc
parens ([Doc] -> Doc
hcat ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> [Doc] -> [Doc]
punctuate Doc
", " (Tidy -> a -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (a -> Doc) -> [a] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [a]
ts)) Doc -> Doc -> Doc
<+> Doc
"=>"

ppMbSizeFun :: F.PPrint v => Maybe (SizeFunV v) -> Doc
ppMbSizeFun :: forall v. PPrint v => Maybe (SizeFunV v) -> Doc
ppMbSizeFun Maybe (SizeFunV v)
Nothing  = Doc
""
ppMbSizeFun (Just SizeFunV v
z) = SizeFunV v -> Doc
forall a. PPrint a => a -> Doc
F.pprint SizeFunV v
z

ppVars :: (F.PPrint a) => F.Tidy -> [a] -> Doc
ppVars :: forall a. PPrint a => Tidy -> [a] -> Doc
ppVars Tidy
k [a]
as = Doc
"forall" Doc -> Doc -> Doc
<+> [Doc] -> Doc
hcat (Doc -> [Doc] -> [Doc]
punctuate Doc
" " (Tidy -> a -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (a -> Doc) -> [a] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [a]
as)) Doc -> Doc -> Doc
<+> Doc
"."

ppFields :: (F.PPrint k, F.PPrint v) => F.Tidy -> Doc -> [(k, v)] -> Doc
ppFields :: forall k v. (PPrint k, PPrint v) => Tidy -> Doc -> [(k, v)] -> Doc
ppFields Tidy
k Doc
sep' [(k, v)]
kvs = [Doc] -> Doc
hcat ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> [Doc] -> [Doc]
punctuate Doc
sep' (Tidy -> (k, v) -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k ((k, v) -> Doc) -> [(k, v)] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(k, v)]
kvs)

instance F.PPrint SpecType => F.PPrint DataConP where
  pprintTidy :: Tidy -> DataConP -> Doc
pprintTidy Tidy
k (DataConP SourcePos
_ DataCon
dc [RTyVar]
vs [PVar RSort]
ps [SpecType]
cs [(LHName, SpecType)]
yts SpecType
t Bool
isGadt Symbol
mname SourcePos
_)
     =  Tidy -> DataCon -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k DataCon
dc
    Doc -> Doc -> Doc
<+> Doc -> Doc
parens ([Doc] -> Doc
hsep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma (Tidy -> RTyVar -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (RTyVar -> Doc) -> [RTyVar] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [RTyVar]
vs)))
    Doc -> Doc -> Doc
<+> Doc -> Doc
parens ([Doc] -> Doc
hsep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma (Tidy -> PVar RSort -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (PVar RSort -> Doc) -> [PVar RSort] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PVar RSort]
ps)))
    Doc -> Doc -> Doc
<+> Doc -> Doc
parens ([Doc] -> Doc
hsep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma (Tidy -> SpecType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (SpecType -> Doc) -> [SpecType] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [SpecType]
cs)))
    Doc -> Doc -> Doc
<+> Doc -> Doc
parens ([Doc] -> Doc
hsep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma (Tidy -> (LHName, SpecType) -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k ((LHName, SpecType) -> Doc) -> [(LHName, SpecType)] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(LHName, SpecType)]
yts)))
    Doc -> Doc -> Doc
<+> Tidy -> Bool -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k Bool
isGadt
    Doc -> Doc -> Doc
<+> Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k Symbol
mname
    Doc -> Doc -> Doc
<+> Tidy -> SpecType -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k SpecType
t

instance F.PPrint SpecType => Show DataConP where
  show :: DataConP -> String
show = DataConP -> String
forall a. PPrint a => a -> String
F.showpp

instance F.PPrint Ghc.DataCon where
  pprintTidy :: Tidy -> DataCon -> Doc
pprintTidy Tidy
_ = String -> Doc
text (String -> Doc) -> (DataCon -> String) -> DataCon -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataCon -> String
forall a. Outputable a => a -> String
showPpr

instance Show Ghc.DataCon where
  show :: DataCon -> String
show = DataCon -> String
forall a. PPrint a => a -> String
F.showpp