module Type.Check.HM.Type (
IsVar(..),
HasLoc(..),
DefLoc(..),
TypeF(..),
Type(..),
varT,
conT,
arrowT,
tupleT,
listT,
Typed(..),
SignatureF(..),
Signature(..),
forAllT,
monoT,
stripSignature,
splitSignature,
typeToSignature,
getTypeVars,
VarSet(..),
differenceVarSet,
varSetToList,
memberVarSet,
HasTypeVars(..),
LocFunctor(..),
setLoc,
TypeFunctor(..),
extractFunType,
extractArrow,
isMono,
isPoly
) where
import Control.DeepSeq (NFData(..))
import Control.Monad
import Data.Containers.ListUtils (nubOrdOn)
import Data.Data
import Data.Eq.Deriving
import Data.Ord.Deriving
import Data.Fix
import Data.Foldable
import Data.Function (on)
import Data.Map.Strict (Map)
import Data.Monoid
import Data.String
import Data.Tuple (swap)
import Data.Text (Text)
import GHC.Generics
import qualified Data.List as L
import qualified Data.Map.Strict as M
import Text.Show.Deriving
class HasLoc f where
type Loc f :: *
getLoc :: f -> Loc f
class DefLoc f where
defLoc :: f
class (Show v, Ord v) => IsVar v where
prettyLetters :: [v]
instance IsVar String where
prettyLetters :: [String]
prettyLetters = [String]
forall a. IsString a => [a]
stringPrettyLetters
instance IsVar Text where
prettyLetters :: [Text]
prettyLetters = [Text]
forall a. IsString a => [a]
stringPrettyLetters
instance IsVar Int where
prettyLetters :: [Int]
prettyLetters = [Int
0..]
stringPrettyLetters :: IsString a => [a]
stringPrettyLetters :: [a]
stringPrettyLetters = (String -> a) -> [String] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> a
forall a. IsString a => String -> a
fromString ([String] -> [a]) -> [String] -> [a]
forall a b. (a -> b) -> a -> b
$ [Int
1..] [Int] -> (Int -> [String]) -> [String]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> String -> [String]) -> String -> Int -> [String]
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> String -> [String]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM [Char
'a'..Char
'z']
instance DefLoc () where
defLoc :: ()
defLoc = ()
data TypeF loc var r
= VarT loc var
| ConT loc var [r]
| ArrowT loc r r
| TupleT loc [r]
| ListT loc r
deriving (TypeF loc var r -> TypeF loc var r -> Bool
(TypeF loc var r -> TypeF loc var r -> Bool)
-> (TypeF loc var r -> TypeF loc var r -> Bool)
-> Eq (TypeF loc var r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc var r.
(Eq loc, Eq var, Eq r) =>
TypeF loc var r -> TypeF loc var r -> Bool
/= :: TypeF loc var r -> TypeF loc var r -> Bool
$c/= :: forall loc var r.
(Eq loc, Eq var, Eq r) =>
TypeF loc var r -> TypeF loc var r -> Bool
== :: TypeF loc var r -> TypeF loc var r -> Bool
$c== :: forall loc var r.
(Eq loc, Eq var, Eq r) =>
TypeF loc var r -> TypeF loc var r -> Bool
Eq, Eq (TypeF loc var r)
Eq (TypeF loc var r)
-> (TypeF loc var r -> TypeF loc var r -> Ordering)
-> (TypeF loc var r -> TypeF loc var r -> Bool)
-> (TypeF loc var r -> TypeF loc var r -> Bool)
-> (TypeF loc var r -> TypeF loc var r -> Bool)
-> (TypeF loc var r -> TypeF loc var r -> Bool)
-> (TypeF loc var r -> TypeF loc var r -> TypeF loc var r)
-> (TypeF loc var r -> TypeF loc var r -> TypeF loc var r)
-> Ord (TypeF loc var r)
TypeF loc var r -> TypeF loc var r -> Bool
TypeF loc var r -> TypeF loc var r -> Ordering
TypeF loc var r -> TypeF loc var r -> TypeF loc var r
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 loc var r. (Ord loc, Ord var, Ord r) => Eq (TypeF loc var r)
forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Bool
forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Ordering
forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> TypeF loc var r
min :: TypeF loc var r -> TypeF loc var r -> TypeF loc var r
$cmin :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> TypeF loc var r
max :: TypeF loc var r -> TypeF loc var r -> TypeF loc var r
$cmax :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> TypeF loc var r
>= :: TypeF loc var r -> TypeF loc var r -> Bool
$c>= :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Bool
> :: TypeF loc var r -> TypeF loc var r -> Bool
$c> :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Bool
<= :: TypeF loc var r -> TypeF loc var r -> Bool
$c<= :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Bool
< :: TypeF loc var r -> TypeF loc var r -> Bool
$c< :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Bool
compare :: TypeF loc var r -> TypeF loc var r -> Ordering
$ccompare :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
TypeF loc var r -> TypeF loc var r -> Ordering
$cp1Ord :: forall loc var r. (Ord loc, Ord var, Ord r) => Eq (TypeF loc var r)
Ord, Int -> TypeF loc var r -> ShowS
[TypeF loc var r] -> ShowS
TypeF loc var r -> String
(Int -> TypeF loc var r -> ShowS)
-> (TypeF loc var r -> String)
-> ([TypeF loc var r] -> ShowS)
-> Show (TypeF loc var r)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall loc var r.
(Show loc, Show var, Show r) =>
Int -> TypeF loc var r -> ShowS
forall loc var r.
(Show loc, Show var, Show r) =>
[TypeF loc var r] -> ShowS
forall loc var r.
(Show loc, Show var, Show r) =>
TypeF loc var r -> String
showList :: [TypeF loc var r] -> ShowS
$cshowList :: forall loc var r.
(Show loc, Show var, Show r) =>
[TypeF loc var r] -> ShowS
show :: TypeF loc var r -> String
$cshow :: forall loc var r.
(Show loc, Show var, Show r) =>
TypeF loc var r -> String
showsPrec :: Int -> TypeF loc var r -> ShowS
$cshowsPrec :: forall loc var r.
(Show loc, Show var, Show r) =>
Int -> TypeF loc var r -> ShowS
Show, a -> TypeF loc var b -> TypeF loc var a
(a -> b) -> TypeF loc var a -> TypeF loc var b
(forall a b. (a -> b) -> TypeF loc var a -> TypeF loc var b)
-> (forall a b. a -> TypeF loc var b -> TypeF loc var a)
-> Functor (TypeF loc var)
forall a b. a -> TypeF loc var b -> TypeF loc var a
forall a b. (a -> b) -> TypeF loc var a -> TypeF loc var b
forall loc var a b. a -> TypeF loc var b -> TypeF loc var a
forall loc var a b. (a -> b) -> TypeF loc var a -> TypeF loc var b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> TypeF loc var b -> TypeF loc var a
$c<$ :: forall loc var a b. a -> TypeF loc var b -> TypeF loc var a
fmap :: (a -> b) -> TypeF loc var a -> TypeF loc var b
$cfmap :: forall loc var a b. (a -> b) -> TypeF loc var a -> TypeF loc var b
Functor, TypeF loc var a -> Bool
(a -> m) -> TypeF loc var a -> m
(a -> b -> b) -> b -> TypeF loc var a -> b
(forall m. Monoid m => TypeF loc var m -> m)
-> (forall m a. Monoid m => (a -> m) -> TypeF loc var a -> m)
-> (forall m a. Monoid m => (a -> m) -> TypeF loc var a -> m)
-> (forall a b. (a -> b -> b) -> b -> TypeF loc var a -> b)
-> (forall a b. (a -> b -> b) -> b -> TypeF loc var a -> b)
-> (forall b a. (b -> a -> b) -> b -> TypeF loc var a -> b)
-> (forall b a. (b -> a -> b) -> b -> TypeF loc var a -> b)
-> (forall a. (a -> a -> a) -> TypeF loc var a -> a)
-> (forall a. (a -> a -> a) -> TypeF loc var a -> a)
-> (forall a. TypeF loc var a -> [a])
-> (forall a. TypeF loc var a -> Bool)
-> (forall a. TypeF loc var a -> Int)
-> (forall a. Eq a => a -> TypeF loc var a -> Bool)
-> (forall a. Ord a => TypeF loc var a -> a)
-> (forall a. Ord a => TypeF loc var a -> a)
-> (forall a. Num a => TypeF loc var a -> a)
-> (forall a. Num a => TypeF loc var a -> a)
-> Foldable (TypeF loc var)
forall a. Eq a => a -> TypeF loc var a -> Bool
forall a. Num a => TypeF loc var a -> a
forall a. Ord a => TypeF loc var a -> a
forall m. Monoid m => TypeF loc var m -> m
forall a. TypeF loc var a -> Bool
forall a. TypeF loc var a -> Int
forall a. TypeF loc var a -> [a]
forall a. (a -> a -> a) -> TypeF loc var a -> a
forall m a. Monoid m => (a -> m) -> TypeF loc var a -> m
forall b a. (b -> a -> b) -> b -> TypeF loc var a -> b
forall a b. (a -> b -> b) -> b -> TypeF loc var a -> b
forall loc var a. Eq a => a -> TypeF loc var a -> Bool
forall loc var a. Num a => TypeF loc var a -> a
forall loc var a. Ord a => TypeF loc var a -> a
forall loc var m. Monoid m => TypeF loc var m -> m
forall loc var a. TypeF loc var a -> Bool
forall loc var a. TypeF loc var a -> Int
forall loc var a. TypeF loc var a -> [a]
forall loc var a. (a -> a -> a) -> TypeF loc var a -> a
forall loc var m a. Monoid m => (a -> m) -> TypeF loc var a -> m
forall loc var b a. (b -> a -> b) -> b -> TypeF loc var a -> b
forall loc var a b. (a -> b -> b) -> b -> TypeF loc var a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: TypeF loc var a -> a
$cproduct :: forall loc var a. Num a => TypeF loc var a -> a
sum :: TypeF loc var a -> a
$csum :: forall loc var a. Num a => TypeF loc var a -> a
minimum :: TypeF loc var a -> a
$cminimum :: forall loc var a. Ord a => TypeF loc var a -> a
maximum :: TypeF loc var a -> a
$cmaximum :: forall loc var a. Ord a => TypeF loc var a -> a
elem :: a -> TypeF loc var a -> Bool
$celem :: forall loc var a. Eq a => a -> TypeF loc var a -> Bool
length :: TypeF loc var a -> Int
$clength :: forall loc var a. TypeF loc var a -> Int
null :: TypeF loc var a -> Bool
$cnull :: forall loc var a. TypeF loc var a -> Bool
toList :: TypeF loc var a -> [a]
$ctoList :: forall loc var a. TypeF loc var a -> [a]
foldl1 :: (a -> a -> a) -> TypeF loc var a -> a
$cfoldl1 :: forall loc var a. (a -> a -> a) -> TypeF loc var a -> a
foldr1 :: (a -> a -> a) -> TypeF loc var a -> a
$cfoldr1 :: forall loc var a. (a -> a -> a) -> TypeF loc var a -> a
foldl' :: (b -> a -> b) -> b -> TypeF loc var a -> b
$cfoldl' :: forall loc var b a. (b -> a -> b) -> b -> TypeF loc var a -> b
foldl :: (b -> a -> b) -> b -> TypeF loc var a -> b
$cfoldl :: forall loc var b a. (b -> a -> b) -> b -> TypeF loc var a -> b
foldr' :: (a -> b -> b) -> b -> TypeF loc var a -> b
$cfoldr' :: forall loc var a b. (a -> b -> b) -> b -> TypeF loc var a -> b
foldr :: (a -> b -> b) -> b -> TypeF loc var a -> b
$cfoldr :: forall loc var a b. (a -> b -> b) -> b -> TypeF loc var a -> b
foldMap' :: (a -> m) -> TypeF loc var a -> m
$cfoldMap' :: forall loc var m a. Monoid m => (a -> m) -> TypeF loc var a -> m
foldMap :: (a -> m) -> TypeF loc var a -> m
$cfoldMap :: forall loc var m a. Monoid m => (a -> m) -> TypeF loc var a -> m
fold :: TypeF loc var m -> m
$cfold :: forall loc var m. Monoid m => TypeF loc var m -> m
Foldable, Functor (TypeF loc var)
Foldable (TypeF loc var)
Functor (TypeF loc var)
-> Foldable (TypeF loc var)
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeF loc var a -> f (TypeF loc var b))
-> (forall (f :: * -> *) a.
Applicative f =>
TypeF loc var (f a) -> f (TypeF loc var a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeF loc var a -> m (TypeF loc var b))
-> (forall (m :: * -> *) a.
Monad m =>
TypeF loc var (m a) -> m (TypeF loc var a))
-> Traversable (TypeF loc var)
(a -> f b) -> TypeF loc var a -> f (TypeF loc var b)
forall loc var. Functor (TypeF loc var)
forall loc var. Foldable (TypeF loc var)
forall loc var (m :: * -> *) a.
Monad m =>
TypeF loc var (m a) -> m (TypeF loc var a)
forall loc var (f :: * -> *) a.
Applicative f =>
TypeF loc var (f a) -> f (TypeF loc var a)
forall loc var (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeF loc var a -> m (TypeF loc var b)
forall loc var (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeF loc var a -> f (TypeF loc var 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 =>
TypeF loc var (m a) -> m (TypeF loc var a)
forall (f :: * -> *) a.
Applicative f =>
TypeF loc var (f a) -> f (TypeF loc var a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeF loc var a -> m (TypeF loc var b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeF loc var a -> f (TypeF loc var b)
sequence :: TypeF loc var (m a) -> m (TypeF loc var a)
$csequence :: forall loc var (m :: * -> *) a.
Monad m =>
TypeF loc var (m a) -> m (TypeF loc var a)
mapM :: (a -> m b) -> TypeF loc var a -> m (TypeF loc var b)
$cmapM :: forall loc var (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeF loc var a -> m (TypeF loc var b)
sequenceA :: TypeF loc var (f a) -> f (TypeF loc var a)
$csequenceA :: forall loc var (f :: * -> *) a.
Applicative f =>
TypeF loc var (f a) -> f (TypeF loc var a)
traverse :: (a -> f b) -> TypeF loc var a -> f (TypeF loc var b)
$ctraverse :: forall loc var (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeF loc var a -> f (TypeF loc var b)
$cp2Traversable :: forall loc var. Foldable (TypeF loc var)
$cp1Traversable :: forall loc var. Functor (TypeF loc var)
Traversable, (forall x. TypeF loc var r -> Rep (TypeF loc var r) x)
-> (forall x. Rep (TypeF loc var r) x -> TypeF loc var r)
-> Generic (TypeF loc var r)
forall x. Rep (TypeF loc var r) x -> TypeF loc var r
forall x. TypeF loc var r -> Rep (TypeF loc var r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall loc var r x. Rep (TypeF loc var r) x -> TypeF loc var r
forall loc var r x. TypeF loc var r -> Rep (TypeF loc var r) x
$cto :: forall loc var r x. Rep (TypeF loc var r) x -> TypeF loc var r
$cfrom :: forall loc var r x. TypeF loc var r -> Rep (TypeF loc var r) x
Generic, Typeable (TypeF loc var r)
DataType
Constr
Typeable (TypeF loc var r)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeF loc var r))
-> (TypeF loc var r -> Constr)
-> (TypeF loc var r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeF loc var r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeF loc var r)))
-> ((forall b. Data b => b -> b)
-> TypeF loc var r -> TypeF loc var r)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r)
-> (forall u.
(forall d. Data d => d -> u) -> TypeF loc var r -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> TypeF loc var r -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r))
-> Data (TypeF loc var r)
TypeF loc var r -> DataType
TypeF loc var r -> Constr
(forall b. Data b => b -> b) -> TypeF loc var r -> TypeF loc var r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeF loc var r)
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) -> TypeF loc var r -> u
forall u. (forall d. Data d => d -> u) -> TypeF loc var r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
forall loc var r.
(Data loc, Data var, Data r) =>
Typeable (TypeF loc var r)
forall loc var r.
(Data loc, Data var, Data r) =>
TypeF loc var r -> DataType
forall loc var r.
(Data loc, Data var, Data r) =>
TypeF loc var r -> Constr
forall loc var r.
(Data loc, Data var, Data r) =>
(forall b. Data b => b -> b) -> TypeF loc var r -> TypeF loc var r
forall loc var r u.
(Data loc, Data var, Data r) =>
Int -> (forall d. Data d => d -> u) -> TypeF loc var r -> u
forall loc var r u.
(Data loc, Data var, Data r) =>
(forall d. Data d => d -> u) -> TypeF loc var r -> [u]
forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeF loc var r)
forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r)
forall loc var r (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeF loc var r))
forall loc var r (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeF loc var r))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeF loc var r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeF loc var r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeF loc var r))
$cListT :: Constr
$cTupleT :: Constr
$cArrowT :: Constr
$cConT :: Constr
$cVarT :: Constr
$tTypeF :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
$cgmapMo :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
gmapMp :: (forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
$cgmapMp :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
gmapM :: (forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
$cgmapM :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> TypeF loc var r -> m (TypeF loc var r)
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeF loc var r -> u
$cgmapQi :: forall loc var r u.
(Data loc, Data var, Data r) =>
Int -> (forall d. Data d => d -> u) -> TypeF loc var r -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeF loc var r -> [u]
$cgmapQ :: forall loc var r u.
(Data loc, Data var, Data r) =>
(forall d. Data d => d -> u) -> TypeF loc var r -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
$cgmapQr :: forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
$cgmapQl :: forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeF loc var r -> r
gmapT :: (forall b. Data b => b -> b) -> TypeF loc var r -> TypeF loc var r
$cgmapT :: forall loc var r.
(Data loc, Data var, Data r) =>
(forall b. Data b => b -> b) -> TypeF loc var r -> TypeF loc var r
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeF loc var r))
$cdataCast2 :: forall loc var r (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TypeF loc var r))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (TypeF loc var r))
$cdataCast1 :: forall loc var r (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TypeF loc var r))
dataTypeOf :: TypeF loc var r -> DataType
$cdataTypeOf :: forall loc var r.
(Data loc, Data var, Data r) =>
TypeF loc var r -> DataType
toConstr :: TypeF loc var r -> Constr
$ctoConstr :: forall loc var r.
(Data loc, Data var, Data r) =>
TypeF loc var r -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeF loc var r)
$cgunfold :: forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TypeF loc var r)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r)
$cgfoldl :: forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r)
$cp1Data :: forall loc var r.
(Data loc, Data var, Data r) =>
Typeable (TypeF loc var r)
Data)
$(deriveShow1 ''TypeF)
$(deriveEq1 ''TypeF)
$(deriveOrd1 ''TypeF)
data Typed loc v a = Typed
{ Typed loc v a -> Type loc v
typed'type :: Type loc v
, Typed loc v a -> a
typed'value :: a
} deriving (Int -> Typed loc v a -> ShowS
[Typed loc v a] -> ShowS
Typed loc v a -> String
(Int -> Typed loc v a -> ShowS)
-> (Typed loc v a -> String)
-> ([Typed loc v a] -> ShowS)
-> Show (Typed loc v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall loc v a.
(Show loc, Show v, Show a) =>
Int -> Typed loc v a -> ShowS
forall loc v a.
(Show loc, Show v, Show a) =>
[Typed loc v a] -> ShowS
forall loc v a.
(Show loc, Show v, Show a) =>
Typed loc v a -> String
showList :: [Typed loc v a] -> ShowS
$cshowList :: forall loc v a.
(Show loc, Show v, Show a) =>
[Typed loc v a] -> ShowS
show :: Typed loc v a -> String
$cshow :: forall loc v a.
(Show loc, Show v, Show a) =>
Typed loc v a -> String
showsPrec :: Int -> Typed loc v a -> ShowS
$cshowsPrec :: forall loc v a.
(Show loc, Show v, Show a) =>
Int -> Typed loc v a -> ShowS
Show, Typed loc v a -> Typed loc v a -> Bool
(Typed loc v a -> Typed loc v a -> Bool)
-> (Typed loc v a -> Typed loc v a -> Bool) -> Eq (Typed loc v a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc v a.
(Eq loc, Eq v, Eq a) =>
Typed loc v a -> Typed loc v a -> Bool
/= :: Typed loc v a -> Typed loc v a -> Bool
$c/= :: forall loc v a.
(Eq loc, Eq v, Eq a) =>
Typed loc v a -> Typed loc v a -> Bool
== :: Typed loc v a -> Typed loc v a -> Bool
$c== :: forall loc v a.
(Eq loc, Eq v, Eq a) =>
Typed loc v a -> Typed loc v a -> Bool
Eq, Eq (Typed loc v a)
Eq (Typed loc v a)
-> (Typed loc v a -> Typed loc v a -> Ordering)
-> (Typed loc v a -> Typed loc v a -> Bool)
-> (Typed loc v a -> Typed loc v a -> Bool)
-> (Typed loc v a -> Typed loc v a -> Bool)
-> (Typed loc v a -> Typed loc v a -> Bool)
-> (Typed loc v a -> Typed loc v a -> Typed loc v a)
-> (Typed loc v a -> Typed loc v a -> Typed loc v a)
-> Ord (Typed loc v a)
Typed loc v a -> Typed loc v a -> Bool
Typed loc v a -> Typed loc v a -> Ordering
Typed loc v a -> Typed loc v a -> Typed loc v a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall loc v a. (Ord loc, Ord v, Ord a) => Eq (Typed loc v a)
forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Bool
forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Ordering
forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Typed loc v a
min :: Typed loc v a -> Typed loc v a -> Typed loc v a
$cmin :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Typed loc v a
max :: Typed loc v a -> Typed loc v a -> Typed loc v a
$cmax :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Typed loc v a
>= :: Typed loc v a -> Typed loc v a -> Bool
$c>= :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Bool
> :: Typed loc v a -> Typed loc v a -> Bool
$c> :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Bool
<= :: Typed loc v a -> Typed loc v a -> Bool
$c<= :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Bool
< :: Typed loc v a -> Typed loc v a -> Bool
$c< :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Bool
compare :: Typed loc v a -> Typed loc v a -> Ordering
$ccompare :: forall loc v a.
(Ord loc, Ord v, Ord a) =>
Typed loc v a -> Typed loc v a -> Ordering
$cp1Ord :: forall loc v a. (Ord loc, Ord v, Ord a) => Eq (Typed loc v a)
Ord, a -> Typed loc v b -> Typed loc v a
(a -> b) -> Typed loc v a -> Typed loc v b
(forall a b. (a -> b) -> Typed loc v a -> Typed loc v b)
-> (forall a b. a -> Typed loc v b -> Typed loc v a)
-> Functor (Typed loc v)
forall a b. a -> Typed loc v b -> Typed loc v a
forall a b. (a -> b) -> Typed loc v a -> Typed loc v b
forall loc v a b. a -> Typed loc v b -> Typed loc v a
forall loc v a b. (a -> b) -> Typed loc v a -> Typed loc v b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Typed loc v b -> Typed loc v a
$c<$ :: forall loc v a b. a -> Typed loc v b -> Typed loc v a
fmap :: (a -> b) -> Typed loc v a -> Typed loc v b
$cfmap :: forall loc v a b. (a -> b) -> Typed loc v a -> Typed loc v b
Functor, Typed loc v a -> Bool
(a -> m) -> Typed loc v a -> m
(a -> b -> b) -> b -> Typed loc v a -> b
(forall m. Monoid m => Typed loc v m -> m)
-> (forall m a. Monoid m => (a -> m) -> Typed loc v a -> m)
-> (forall m a. Monoid m => (a -> m) -> Typed loc v a -> m)
-> (forall a b. (a -> b -> b) -> b -> Typed loc v a -> b)
-> (forall a b. (a -> b -> b) -> b -> Typed loc v a -> b)
-> (forall b a. (b -> a -> b) -> b -> Typed loc v a -> b)
-> (forall b a. (b -> a -> b) -> b -> Typed loc v a -> b)
-> (forall a. (a -> a -> a) -> Typed loc v a -> a)
-> (forall a. (a -> a -> a) -> Typed loc v a -> a)
-> (forall a. Typed loc v a -> [a])
-> (forall a. Typed loc v a -> Bool)
-> (forall a. Typed loc v a -> Int)
-> (forall a. Eq a => a -> Typed loc v a -> Bool)
-> (forall a. Ord a => Typed loc v a -> a)
-> (forall a. Ord a => Typed loc v a -> a)
-> (forall a. Num a => Typed loc v a -> a)
-> (forall a. Num a => Typed loc v a -> a)
-> Foldable (Typed loc v)
forall a. Eq a => a -> Typed loc v a -> Bool
forall a. Num a => Typed loc v a -> a
forall a. Ord a => Typed loc v a -> a
forall m. Monoid m => Typed loc v m -> m
forall a. Typed loc v a -> Bool
forall a. Typed loc v a -> Int
forall a. Typed loc v a -> [a]
forall a. (a -> a -> a) -> Typed loc v a -> a
forall m a. Monoid m => (a -> m) -> Typed loc v a -> m
forall b a. (b -> a -> b) -> b -> Typed loc v a -> b
forall a b. (a -> b -> b) -> b -> Typed loc v a -> b
forall loc v a. Eq a => a -> Typed loc v a -> Bool
forall loc v a. Num a => Typed loc v a -> a
forall loc v a. Ord a => Typed loc v a -> a
forall loc v m. Monoid m => Typed loc v m -> m
forall loc v a. Typed loc v a -> Bool
forall loc v a. Typed loc v a -> Int
forall loc v a. Typed loc v a -> [a]
forall loc v a. (a -> a -> a) -> Typed loc v a -> a
forall loc v m a. Monoid m => (a -> m) -> Typed loc v a -> m
forall loc v b a. (b -> a -> b) -> b -> Typed loc v a -> b
forall loc v a b. (a -> b -> b) -> b -> Typed loc 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
product :: Typed loc v a -> a
$cproduct :: forall loc v a. Num a => Typed loc v a -> a
sum :: Typed loc v a -> a
$csum :: forall loc v a. Num a => Typed loc v a -> a
minimum :: Typed loc v a -> a
$cminimum :: forall loc v a. Ord a => Typed loc v a -> a
maximum :: Typed loc v a -> a
$cmaximum :: forall loc v a. Ord a => Typed loc v a -> a
elem :: a -> Typed loc v a -> Bool
$celem :: forall loc v a. Eq a => a -> Typed loc v a -> Bool
length :: Typed loc v a -> Int
$clength :: forall loc v a. Typed loc v a -> Int
null :: Typed loc v a -> Bool
$cnull :: forall loc v a. Typed loc v a -> Bool
toList :: Typed loc v a -> [a]
$ctoList :: forall loc v a. Typed loc v a -> [a]
foldl1 :: (a -> a -> a) -> Typed loc v a -> a
$cfoldl1 :: forall loc v a. (a -> a -> a) -> Typed loc v a -> a
foldr1 :: (a -> a -> a) -> Typed loc v a -> a
$cfoldr1 :: forall loc v a. (a -> a -> a) -> Typed loc v a -> a
foldl' :: (b -> a -> b) -> b -> Typed loc v a -> b
$cfoldl' :: forall loc v b a. (b -> a -> b) -> b -> Typed loc v a -> b
foldl :: (b -> a -> b) -> b -> Typed loc v a -> b
$cfoldl :: forall loc v b a. (b -> a -> b) -> b -> Typed loc v a -> b
foldr' :: (a -> b -> b) -> b -> Typed loc v a -> b
$cfoldr' :: forall loc v a b. (a -> b -> b) -> b -> Typed loc v a -> b
foldr :: (a -> b -> b) -> b -> Typed loc v a -> b
$cfoldr :: forall loc v a b. (a -> b -> b) -> b -> Typed loc v a -> b
foldMap' :: (a -> m) -> Typed loc v a -> m
$cfoldMap' :: forall loc v m a. Monoid m => (a -> m) -> Typed loc v a -> m
foldMap :: (a -> m) -> Typed loc v a -> m
$cfoldMap :: forall loc v m a. Monoid m => (a -> m) -> Typed loc v a -> m
fold :: Typed loc v m -> m
$cfold :: forall loc v m. Monoid m => Typed loc v m -> m
Foldable, Functor (Typed loc v)
Foldable (Typed loc v)
Functor (Typed loc v)
-> Foldable (Typed loc v)
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Typed loc v a -> f (Typed loc v b))
-> (forall (f :: * -> *) a.
Applicative f =>
Typed loc v (f a) -> f (Typed loc v a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Typed loc v a -> m (Typed loc v b))
-> (forall (m :: * -> *) a.
Monad m =>
Typed loc v (m a) -> m (Typed loc v a))
-> Traversable (Typed loc v)
(a -> f b) -> Typed loc v a -> f (Typed loc v b)
forall loc v. Functor (Typed loc v)
forall loc v. Foldable (Typed loc v)
forall loc v (m :: * -> *) a.
Monad m =>
Typed loc v (m a) -> m (Typed loc v a)
forall loc v (f :: * -> *) a.
Applicative f =>
Typed loc v (f a) -> f (Typed loc v a)
forall loc v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Typed loc v a -> m (Typed loc v b)
forall loc v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Typed loc v a -> f (Typed loc 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 =>
Typed loc v (m a) -> m (Typed loc v a)
forall (f :: * -> *) a.
Applicative f =>
Typed loc v (f a) -> f (Typed loc v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Typed loc v a -> m (Typed loc v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Typed loc v a -> f (Typed loc v b)
sequence :: Typed loc v (m a) -> m (Typed loc v a)
$csequence :: forall loc v (m :: * -> *) a.
Monad m =>
Typed loc v (m a) -> m (Typed loc v a)
mapM :: (a -> m b) -> Typed loc v a -> m (Typed loc v b)
$cmapM :: forall loc v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Typed loc v a -> m (Typed loc v b)
sequenceA :: Typed loc v (f a) -> f (Typed loc v a)
$csequenceA :: forall loc v (f :: * -> *) a.
Applicative f =>
Typed loc v (f a) -> f (Typed loc v a)
traverse :: (a -> f b) -> Typed loc v a -> f (Typed loc v b)
$ctraverse :: forall loc v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Typed loc v a -> f (Typed loc v b)
$cp2Traversable :: forall loc v. Foldable (Typed loc v)
$cp1Traversable :: forall loc v. Functor (Typed loc v)
Traversable, Typeable (Typed loc v a)
DataType
Constr
Typeable (Typed loc v a)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed loc v a))
-> (Typed loc v a -> Constr)
-> (Typed loc v a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed loc v a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Typed loc v a)))
-> ((forall b. Data b => b -> b) -> Typed loc v a -> Typed loc v a)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Typed loc v a -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Typed loc v a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a))
-> Data (Typed loc v a)
Typed loc v a -> DataType
Typed loc v a -> Constr
(forall b. Data b => b -> b) -> Typed loc v a -> Typed loc v a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed loc v a)
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) -> Typed loc v a -> u
forall u. (forall d. Data d => d -> u) -> Typed loc v a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
forall loc v a.
(Data loc, Data v, Data a) =>
Typeable (Typed loc v a)
forall loc v a.
(Data loc, Data v, Data a) =>
Typed loc v a -> DataType
forall loc v a.
(Data loc, Data v, Data a) =>
Typed loc v a -> Constr
forall loc v a.
(Data loc, Data v, Data a) =>
(forall b. Data b => b -> b) -> Typed loc v a -> Typed loc v a
forall loc v a u.
(Data loc, Data v, Data a) =>
Int -> (forall d. Data d => d -> u) -> Typed loc v a -> u
forall loc v a u.
(Data loc, Data v, Data a) =>
(forall d. Data d => d -> u) -> Typed loc v a -> [u]
forall loc v a r r'.
(Data loc, Data v, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
forall loc v a r r'.
(Data loc, Data v, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
forall loc v a (c :: * -> *).
(Data loc, Data v, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed loc v a)
forall loc v a (c :: * -> *).
(Data loc, Data v, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a)
forall loc v a (t :: * -> *) (c :: * -> *).
(Data loc, Data v, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed loc v a))
forall loc v a (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data v, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Typed loc v a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed loc v a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed loc v a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Typed loc v a))
$cTyped :: Constr
$tTyped :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
$cgmapMo :: forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
gmapMp :: (forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
$cgmapMp :: forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
gmapM :: (forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
$cgmapM :: forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Typed loc v a -> m (Typed loc v a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Typed loc v a -> u
$cgmapQi :: forall loc v a u.
(Data loc, Data v, Data a) =>
Int -> (forall d. Data d => d -> u) -> Typed loc v a -> u
gmapQ :: (forall d. Data d => d -> u) -> Typed loc v a -> [u]
$cgmapQ :: forall loc v a u.
(Data loc, Data v, Data a) =>
(forall d. Data d => d -> u) -> Typed loc v a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
$cgmapQr :: forall loc v a r r'.
(Data loc, Data v, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
$cgmapQl :: forall loc v a r r'.
(Data loc, Data v, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r
gmapT :: (forall b. Data b => b -> b) -> Typed loc v a -> Typed loc v a
$cgmapT :: forall loc v a.
(Data loc, Data v, Data a) =>
(forall b. Data b => b -> b) -> Typed loc v a -> Typed loc v a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Typed loc v a))
$cdataCast2 :: forall loc v a (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data v, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Typed loc v a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Typed loc v a))
$cdataCast1 :: forall loc v a (t :: * -> *) (c :: * -> *).
(Data loc, Data v, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Typed loc v a))
dataTypeOf :: Typed loc v a -> DataType
$cdataTypeOf :: forall loc v a.
(Data loc, Data v, Data a) =>
Typed loc v a -> DataType
toConstr :: Typed loc v a -> Constr
$ctoConstr :: forall loc v a.
(Data loc, Data v, Data a) =>
Typed loc v a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed loc v a)
$cgunfold :: forall loc v a (c :: * -> *).
(Data loc, Data v, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Typed loc v a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a)
$cgfoldl :: forall loc v a (c :: * -> *).
(Data loc, Data v, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a)
$cp1Data :: forall loc v a.
(Data loc, Data v, Data a) =>
Typeable (Typed loc v a)
Data)
newtype Type loc var = Type { Type loc var -> Fix (TypeF loc var)
unType :: Fix (TypeF loc var) }
deriving (Int -> Type loc var -> ShowS
[Type loc var] -> ShowS
Type loc var -> String
(Int -> Type loc var -> ShowS)
-> (Type loc var -> String)
-> ([Type loc var] -> ShowS)
-> Show (Type loc var)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall loc var.
(Show loc, Show var) =>
Int -> Type loc var -> ShowS
forall loc var. (Show loc, Show var) => [Type loc var] -> ShowS
forall loc var. (Show loc, Show var) => Type loc var -> String
showList :: [Type loc var] -> ShowS
$cshowList :: forall loc var. (Show loc, Show var) => [Type loc var] -> ShowS
show :: Type loc var -> String
$cshow :: forall loc var. (Show loc, Show var) => Type loc var -> String
showsPrec :: Int -> Type loc var -> ShowS
$cshowsPrec :: forall loc var.
(Show loc, Show var) =>
Int -> Type loc var -> ShowS
Show, Type loc var -> Type loc var -> Bool
(Type loc var -> Type loc var -> Bool)
-> (Type loc var -> Type loc var -> Bool) -> Eq (Type loc var)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc var.
(Eq loc, Eq var) =>
Type loc var -> Type loc var -> Bool
/= :: Type loc var -> Type loc var -> Bool
$c/= :: forall loc var.
(Eq loc, Eq var) =>
Type loc var -> Type loc var -> Bool
== :: Type loc var -> Type loc var -> Bool
$c== :: forall loc var.
(Eq loc, Eq var) =>
Type loc var -> Type loc var -> Bool
Eq, Eq (Type loc var)
Eq (Type loc var)
-> (Type loc var -> Type loc var -> Ordering)
-> (Type loc var -> Type loc var -> Bool)
-> (Type loc var -> Type loc var -> Bool)
-> (Type loc var -> Type loc var -> Bool)
-> (Type loc var -> Type loc var -> Bool)
-> (Type loc var -> Type loc var -> Type loc var)
-> (Type loc var -> Type loc var -> Type loc var)
-> Ord (Type loc var)
Type loc var -> Type loc var -> Bool
Type loc var -> Type loc var -> Ordering
Type loc var -> Type loc var -> Type loc var
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 loc var. (Ord loc, Ord var) => Eq (Type loc var)
forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Bool
forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Ordering
forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Type loc var
min :: Type loc var -> Type loc var -> Type loc var
$cmin :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Type loc var
max :: Type loc var -> Type loc var -> Type loc var
$cmax :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Type loc var
>= :: Type loc var -> Type loc var -> Bool
$c>= :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Bool
> :: Type loc var -> Type loc var -> Bool
$c> :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Bool
<= :: Type loc var -> Type loc var -> Bool
$c<= :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Bool
< :: Type loc var -> Type loc var -> Bool
$c< :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Bool
compare :: Type loc var -> Type loc var -> Ordering
$ccompare :: forall loc var.
(Ord loc, Ord var) =>
Type loc var -> Type loc var -> Ordering
$cp1Ord :: forall loc var. (Ord loc, Ord var) => Eq (Type loc var)
Ord, (forall x. Type loc var -> Rep (Type loc var) x)
-> (forall x. Rep (Type loc var) x -> Type loc var)
-> Generic (Type loc var)
forall x. Rep (Type loc var) x -> Type loc var
forall x. Type loc var -> Rep (Type loc var) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall loc var x. Rep (Type loc var) x -> Type loc var
forall loc var x. Type loc var -> Rep (Type loc var) x
$cto :: forall loc var x. Rep (Type loc var) x -> Type loc var
$cfrom :: forall loc var x. Type loc var -> Rep (Type loc var) x
Generic, Typeable (Type loc var)
DataType
Constr
Typeable (Type loc var)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type loc var -> c (Type loc var))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type loc var))
-> (Type loc var -> Constr)
-> (Type loc var -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Type loc var)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type loc var)))
-> ((forall b. Data b => b -> b) -> Type loc var -> Type loc var)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type loc var -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Type loc var -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var))
-> Data (Type loc var)
Type loc var -> DataType
Type loc var -> Constr
(forall b. Data b => b -> b) -> Type loc var -> Type loc var
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type loc var -> c (Type loc var)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type loc var)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type loc var))
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) -> Type loc var -> u
forall u. (forall d. Data d => d -> u) -> Type loc var -> [u]
forall loc var. (Data loc, Data var) => Typeable (Type loc var)
forall loc var. (Data loc, Data var) => Type loc var -> DataType
forall loc var. (Data loc, Data var) => Type loc var -> Constr
forall loc var.
(Data loc, Data var) =>
(forall b. Data b => b -> b) -> Type loc var -> Type loc var
forall loc var u.
(Data loc, Data var) =>
Int -> (forall d. Data d => d -> u) -> Type loc var -> u
forall loc var u.
(Data loc, Data var) =>
(forall d. Data d => d -> u) -> Type loc var -> [u]
forall loc var r r'.
(Data loc, Data var) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
forall loc var r r'.
(Data loc, Data var) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
forall loc var (m :: * -> *).
(Data loc, Data var, Monad m) =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
forall loc var (m :: * -> *).
(Data loc, Data var, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type loc var)
forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type loc var -> c (Type loc var)
forall loc var (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Type loc var))
forall loc var (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type loc var))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type loc var)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type loc var -> c (Type loc var)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Type loc var))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type loc var))
$cType :: Constr
$tType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
$cgmapMo :: forall loc var (m :: * -> *).
(Data loc, Data var, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
gmapMp :: (forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
$cgmapMp :: forall loc var (m :: * -> *).
(Data loc, Data var, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
gmapM :: (forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
$cgmapM :: forall loc var (m :: * -> *).
(Data loc, Data var, Monad m) =>
(forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Type loc var -> u
$cgmapQi :: forall loc var u.
(Data loc, Data var) =>
Int -> (forall d. Data d => d -> u) -> Type loc var -> u
gmapQ :: (forall d. Data d => d -> u) -> Type loc var -> [u]
$cgmapQ :: forall loc var u.
(Data loc, Data var) =>
(forall d. Data d => d -> u) -> Type loc var -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
$cgmapQr :: forall loc var r r'.
(Data loc, Data var) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
$cgmapQl :: forall loc var r r'.
(Data loc, Data var) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Type loc var -> r
gmapT :: (forall b. Data b => b -> b) -> Type loc var -> Type loc var
$cgmapT :: forall loc var.
(Data loc, Data var) =>
(forall b. Data b => b -> b) -> Type loc var -> Type loc var
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type loc var))
$cdataCast2 :: forall loc var (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Type loc var))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Type loc var))
$cdataCast1 :: forall loc var (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Type loc var))
dataTypeOf :: Type loc var -> DataType
$cdataTypeOf :: forall loc var. (Data loc, Data var) => Type loc var -> DataType
toConstr :: Type loc var -> Constr
$ctoConstr :: forall loc var. (Data loc, Data var) => Type loc var -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type loc var)
$cgunfold :: forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Type loc var)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type loc var -> c (Type loc var)
$cgfoldl :: forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type loc var -> c (Type loc var)
$cp1Data :: forall loc var. (Data loc, Data var) => Typeable (Type loc var)
Data)
instance HasLoc (Type loc v) where
type Loc (Type loc v) = loc
getLoc :: Type loc v -> Loc (Type loc v)
getLoc (Type (Fix TypeF loc v (Fix (TypeF loc v))
x)) = case TypeF loc v (Fix (TypeF loc v))
x of
VarT loc
loc v
_ -> loc
Loc (Type loc v)
loc
ConT loc
loc v
_ [Fix (TypeF loc v)]
_ -> loc
Loc (Type loc v)
loc
ArrowT loc
loc Fix (TypeF loc v)
_ Fix (TypeF loc v)
_ -> loc
Loc (Type loc v)
loc
TupleT loc
loc [Fix (TypeF loc v)]
_ -> loc
Loc (Type loc v)
loc
ListT loc
loc Fix (TypeF loc v)
_ -> loc
Loc (Type loc v)
loc
instance (NFData loc, NFData var) => NFData (Type loc var) where
rnf :: Type loc var -> ()
rnf (Type Fix (TypeF loc var)
m) = (TypeF loc var () -> ()) -> Fix (TypeF loc var) -> ()
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TypeF loc var () -> ()
go Fix (TypeF loc var)
m where
go :: TypeF loc var () -> ()
go = \case
VarT loc
l var
v -> loc -> ()
forall a. NFData a => a -> ()
rnf loc
l () -> () -> ()
`seq` var -> ()
forall a. NFData a => a -> ()
rnf var
v
ConT loc
l var
v [()]
x -> loc -> ()
forall a. NFData a => a -> ()
rnf loc
l () -> () -> ()
`seq` var -> ()
forall a. NFData a => a -> ()
rnf var
v () -> () -> ()
`seq` [()] -> ()
forall a. NFData a => a -> ()
rnf [()]
x
ArrowT loc
l ()
a ()
b -> loc -> ()
forall a. NFData a => a -> ()
rnf loc
l () -> () -> ()
`seq` () -> ()
forall a. NFData a => a -> ()
rnf ()
a () -> () -> ()
`seq` () -> ()
forall a. NFData a => a -> ()
rnf ()
b
TupleT loc
l [()]
x -> loc -> ()
forall a. NFData a => a -> ()
rnf loc
l () -> () -> ()
`seq` [()] -> ()
forall a. NFData a => a -> ()
rnf [()]
x
ListT loc
l ()
x -> loc -> ()
forall a. NFData a => a -> ()
rnf loc
l () -> () -> ()
`seq` () -> ()
forall a. NFData a => a -> ()
rnf ()
x
varT :: loc -> var -> Type loc var
varT :: loc -> var -> Type loc var
varT loc
loc var
var = Fix (TypeF loc var) -> Type loc var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF loc var) -> Type loc var)
-> Fix (TypeF loc var) -> Type loc var
forall a b. (a -> b) -> a -> b
$ TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var))
-> TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall a b. (a -> b) -> a -> b
$ loc -> var -> TypeF loc var (Fix (TypeF loc var))
forall loc var r. loc -> var -> TypeF loc var r
VarT loc
loc var
var
conT :: loc -> var -> [Type loc var] -> Type loc var
conT :: loc -> var -> [Type loc var] -> Type loc var
conT loc
loc var
name [Type loc var]
args = Fix (TypeF loc var) -> Type loc var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF loc var) -> Type loc var)
-> Fix (TypeF loc var) -> Type loc var
forall a b. (a -> b) -> a -> b
$ TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var))
-> TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall a b. (a -> b) -> a -> b
$ loc
-> var
-> [Fix (TypeF loc var)]
-> TypeF loc var (Fix (TypeF loc var))
forall loc var r. loc -> var -> [r] -> TypeF loc var r
ConT loc
loc var
name ([Fix (TypeF loc var)] -> TypeF loc var (Fix (TypeF loc var)))
-> [Fix (TypeF loc var)] -> TypeF loc var (Fix (TypeF loc var))
forall a b. (a -> b) -> a -> b
$ (Type loc var -> Fix (TypeF loc var))
-> [Type loc var] -> [Fix (TypeF loc var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type loc var -> Fix (TypeF loc var)
forall loc var. Type loc var -> Fix (TypeF loc var)
unType ([Type loc var] -> [Fix (TypeF loc var)])
-> [Type loc var] -> [Fix (TypeF loc var)]
forall a b. (a -> b) -> a -> b
$ [Type loc var]
args
arrowT :: loc -> Type loc v -> Type loc v -> Type loc v
arrowT :: loc -> Type loc v -> Type loc v -> Type loc v
arrowT loc
loc (Type Fix (TypeF loc v)
t0) (Type Fix (TypeF loc v)
t1) = Fix (TypeF loc v) -> Type loc v
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF loc v) -> Type loc v)
-> Fix (TypeF loc v) -> Type loc v
forall a b. (a -> b) -> a -> b
$ TypeF loc v (Fix (TypeF loc v)) -> Fix (TypeF loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF loc v (Fix (TypeF loc v)) -> Fix (TypeF loc v))
-> TypeF loc v (Fix (TypeF loc v)) -> Fix (TypeF loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TypeF loc v)
-> Fix (TypeF loc v)
-> TypeF loc v (Fix (TypeF loc v))
forall loc var r. loc -> r -> r -> TypeF loc var r
ArrowT loc
loc Fix (TypeF loc v)
t0 Fix (TypeF loc v)
t1
tupleT :: loc -> [Type loc var] -> Type loc var
tupleT :: loc -> [Type loc var] -> Type loc var
tupleT loc
loc [Type loc var]
ts = Fix (TypeF loc var) -> Type loc var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF loc var) -> Type loc var)
-> Fix (TypeF loc var) -> Type loc var
forall a b. (a -> b) -> a -> b
$ TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var))
-> TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall a b. (a -> b) -> a -> b
$ loc -> [Fix (TypeF loc var)] -> TypeF loc var (Fix (TypeF loc var))
forall loc var r. loc -> [r] -> TypeF loc var r
TupleT loc
loc ([Fix (TypeF loc var)] -> TypeF loc var (Fix (TypeF loc var)))
-> [Fix (TypeF loc var)] -> TypeF loc var (Fix (TypeF loc var))
forall a b. (a -> b) -> a -> b
$ (Type loc var -> Fix (TypeF loc var))
-> [Type loc var] -> [Fix (TypeF loc var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type loc var -> Fix (TypeF loc var)
forall loc var. Type loc var -> Fix (TypeF loc var)
unType [Type loc var]
ts
listT :: loc -> Type loc var -> Type loc var
listT :: loc -> Type loc var -> Type loc var
listT loc
loc (Type Fix (TypeF loc var)
t) = Fix (TypeF loc var) -> Type loc var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF loc var) -> Type loc var)
-> Fix (TypeF loc var) -> Type loc var
forall a b. (a -> b) -> a -> b
$ TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var))
-> TypeF loc var (Fix (TypeF loc var)) -> Fix (TypeF loc var)
forall a b. (a -> b) -> a -> b
$ loc -> Fix (TypeF loc var) -> TypeF loc var (Fix (TypeF loc var))
forall loc var r. loc -> r -> TypeF loc var r
ListT loc
loc Fix (TypeF loc var)
t
data SignatureF loc var r
= ForAllT loc var r
| MonoT (Type loc var)
deriving (SignatureF loc var r -> SignatureF loc var r -> Bool
(SignatureF loc var r -> SignatureF loc var r -> Bool)
-> (SignatureF loc var r -> SignatureF loc var r -> Bool)
-> Eq (SignatureF loc var r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc var r.
(Eq loc, Eq var, Eq r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
/= :: SignatureF loc var r -> SignatureF loc var r -> Bool
$c/= :: forall loc var r.
(Eq loc, Eq var, Eq r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
== :: SignatureF loc var r -> SignatureF loc var r -> Bool
$c== :: forall loc var r.
(Eq loc, Eq var, Eq r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
Eq, Eq (SignatureF loc var r)
Eq (SignatureF loc var r)
-> (SignatureF loc var r -> SignatureF loc var r -> Ordering)
-> (SignatureF loc var r -> SignatureF loc var r -> Bool)
-> (SignatureF loc var r -> SignatureF loc var r -> Bool)
-> (SignatureF loc var r -> SignatureF loc var r -> Bool)
-> (SignatureF loc var r -> SignatureF loc var r -> Bool)
-> (SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r)
-> (SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r)
-> Ord (SignatureF loc var r)
SignatureF loc var r -> SignatureF loc var r -> Bool
SignatureF loc var r -> SignatureF loc var r -> Ordering
SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r
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 loc var r.
(Ord loc, Ord var, Ord r) =>
Eq (SignatureF loc var r)
forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Ordering
forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r
min :: SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r
$cmin :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r
max :: SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r
$cmax :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r
-> SignatureF loc var r -> SignatureF loc var r
>= :: SignatureF loc var r -> SignatureF loc var r -> Bool
$c>= :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
> :: SignatureF loc var r -> SignatureF loc var r -> Bool
$c> :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
<= :: SignatureF loc var r -> SignatureF loc var r -> Bool
$c<= :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
< :: SignatureF loc var r -> SignatureF loc var r -> Bool
$c< :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Bool
compare :: SignatureF loc var r -> SignatureF loc var r -> Ordering
$ccompare :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
SignatureF loc var r -> SignatureF loc var r -> Ordering
$cp1Ord :: forall loc var r.
(Ord loc, Ord var, Ord r) =>
Eq (SignatureF loc var r)
Ord, Int -> SignatureF loc var r -> ShowS
[SignatureF loc var r] -> ShowS
SignatureF loc var r -> String
(Int -> SignatureF loc var r -> ShowS)
-> (SignatureF loc var r -> String)
-> ([SignatureF loc var r] -> ShowS)
-> Show (SignatureF loc var r)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall loc var r.
(Show loc, Show var, Show r) =>
Int -> SignatureF loc var r -> ShowS
forall loc var r.
(Show loc, Show var, Show r) =>
[SignatureF loc var r] -> ShowS
forall loc var r.
(Show loc, Show var, Show r) =>
SignatureF loc var r -> String
showList :: [SignatureF loc var r] -> ShowS
$cshowList :: forall loc var r.
(Show loc, Show var, Show r) =>
[SignatureF loc var r] -> ShowS
show :: SignatureF loc var r -> String
$cshow :: forall loc var r.
(Show loc, Show var, Show r) =>
SignatureF loc var r -> String
showsPrec :: Int -> SignatureF loc var r -> ShowS
$cshowsPrec :: forall loc var r.
(Show loc, Show var, Show r) =>
Int -> SignatureF loc var r -> ShowS
Show, a -> SignatureF loc var b -> SignatureF loc var a
(a -> b) -> SignatureF loc var a -> SignatureF loc var b
(forall a b.
(a -> b) -> SignatureF loc var a -> SignatureF loc var b)
-> (forall a b. a -> SignatureF loc var b -> SignatureF loc var a)
-> Functor (SignatureF loc var)
forall a b. a -> SignatureF loc var b -> SignatureF loc var a
forall a b.
(a -> b) -> SignatureF loc var a -> SignatureF loc var b
forall loc var a b.
a -> SignatureF loc var b -> SignatureF loc var a
forall loc var a b.
(a -> b) -> SignatureF loc var a -> SignatureF loc var b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SignatureF loc var b -> SignatureF loc var a
$c<$ :: forall loc var a b.
a -> SignatureF loc var b -> SignatureF loc var a
fmap :: (a -> b) -> SignatureF loc var a -> SignatureF loc var b
$cfmap :: forall loc var a b.
(a -> b) -> SignatureF loc var a -> SignatureF loc var b
Functor, SignatureF loc var a -> Bool
(a -> m) -> SignatureF loc var a -> m
(a -> b -> b) -> b -> SignatureF loc var a -> b
(forall m. Monoid m => SignatureF loc var m -> m)
-> (forall m a. Monoid m => (a -> m) -> SignatureF loc var a -> m)
-> (forall m a. Monoid m => (a -> m) -> SignatureF loc var a -> m)
-> (forall a b. (a -> b -> b) -> b -> SignatureF loc var a -> b)
-> (forall a b. (a -> b -> b) -> b -> SignatureF loc var a -> b)
-> (forall b a. (b -> a -> b) -> b -> SignatureF loc var a -> b)
-> (forall b a. (b -> a -> b) -> b -> SignatureF loc var a -> b)
-> (forall a. (a -> a -> a) -> SignatureF loc var a -> a)
-> (forall a. (a -> a -> a) -> SignatureF loc var a -> a)
-> (forall a. SignatureF loc var a -> [a])
-> (forall a. SignatureF loc var a -> Bool)
-> (forall a. SignatureF loc var a -> Int)
-> (forall a. Eq a => a -> SignatureF loc var a -> Bool)
-> (forall a. Ord a => SignatureF loc var a -> a)
-> (forall a. Ord a => SignatureF loc var a -> a)
-> (forall a. Num a => SignatureF loc var a -> a)
-> (forall a. Num a => SignatureF loc var a -> a)
-> Foldable (SignatureF loc var)
forall a. Eq a => a -> SignatureF loc var a -> Bool
forall a. Num a => SignatureF loc var a -> a
forall a. Ord a => SignatureF loc var a -> a
forall m. Monoid m => SignatureF loc var m -> m
forall a. SignatureF loc var a -> Bool
forall a. SignatureF loc var a -> Int
forall a. SignatureF loc var a -> [a]
forall a. (a -> a -> a) -> SignatureF loc var a -> a
forall m a. Monoid m => (a -> m) -> SignatureF loc var a -> m
forall b a. (b -> a -> b) -> b -> SignatureF loc var a -> b
forall a b. (a -> b -> b) -> b -> SignatureF loc var a -> b
forall loc var a. Eq a => a -> SignatureF loc var a -> Bool
forall loc var a. Num a => SignatureF loc var a -> a
forall loc var a. Ord a => SignatureF loc var a -> a
forall loc var m. Monoid m => SignatureF loc var m -> m
forall loc var a. SignatureF loc var a -> Bool
forall loc var a. SignatureF loc var a -> Int
forall loc var a. SignatureF loc var a -> [a]
forall loc var a. (a -> a -> a) -> SignatureF loc var a -> a
forall loc var m a.
Monoid m =>
(a -> m) -> SignatureF loc var a -> m
forall loc var b a. (b -> a -> b) -> b -> SignatureF loc var a -> b
forall loc var a b. (a -> b -> b) -> b -> SignatureF loc var a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: SignatureF loc var a -> a
$cproduct :: forall loc var a. Num a => SignatureF loc var a -> a
sum :: SignatureF loc var a -> a
$csum :: forall loc var a. Num a => SignatureF loc var a -> a
minimum :: SignatureF loc var a -> a
$cminimum :: forall loc var a. Ord a => SignatureF loc var a -> a
maximum :: SignatureF loc var a -> a
$cmaximum :: forall loc var a. Ord a => SignatureF loc var a -> a
elem :: a -> SignatureF loc var a -> Bool
$celem :: forall loc var a. Eq a => a -> SignatureF loc var a -> Bool
length :: SignatureF loc var a -> Int
$clength :: forall loc var a. SignatureF loc var a -> Int
null :: SignatureF loc var a -> Bool
$cnull :: forall loc var a. SignatureF loc var a -> Bool
toList :: SignatureF loc var a -> [a]
$ctoList :: forall loc var a. SignatureF loc var a -> [a]
foldl1 :: (a -> a -> a) -> SignatureF loc var a -> a
$cfoldl1 :: forall loc var a. (a -> a -> a) -> SignatureF loc var a -> a
foldr1 :: (a -> a -> a) -> SignatureF loc var a -> a
$cfoldr1 :: forall loc var a. (a -> a -> a) -> SignatureF loc var a -> a
foldl' :: (b -> a -> b) -> b -> SignatureF loc var a -> b
$cfoldl' :: forall loc var b a. (b -> a -> b) -> b -> SignatureF loc var a -> b
foldl :: (b -> a -> b) -> b -> SignatureF loc var a -> b
$cfoldl :: forall loc var b a. (b -> a -> b) -> b -> SignatureF loc var a -> b
foldr' :: (a -> b -> b) -> b -> SignatureF loc var a -> b
$cfoldr' :: forall loc var a b. (a -> b -> b) -> b -> SignatureF loc var a -> b
foldr :: (a -> b -> b) -> b -> SignatureF loc var a -> b
$cfoldr :: forall loc var a b. (a -> b -> b) -> b -> SignatureF loc var a -> b
foldMap' :: (a -> m) -> SignatureF loc var a -> m
$cfoldMap' :: forall loc var m a.
Monoid m =>
(a -> m) -> SignatureF loc var a -> m
foldMap :: (a -> m) -> SignatureF loc var a -> m
$cfoldMap :: forall loc var m a.
Monoid m =>
(a -> m) -> SignatureF loc var a -> m
fold :: SignatureF loc var m -> m
$cfold :: forall loc var m. Monoid m => SignatureF loc var m -> m
Foldable, Functor (SignatureF loc var)
Foldable (SignatureF loc var)
Functor (SignatureF loc var)
-> Foldable (SignatureF loc var)
-> (forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SignatureF loc var a -> f (SignatureF loc var b))
-> (forall (f :: * -> *) a.
Applicative f =>
SignatureF loc var (f a) -> f (SignatureF loc var a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SignatureF loc var a -> m (SignatureF loc var b))
-> (forall (m :: * -> *) a.
Monad m =>
SignatureF loc var (m a) -> m (SignatureF loc var a))
-> Traversable (SignatureF loc var)
(a -> f b) -> SignatureF loc var a -> f (SignatureF loc var b)
forall loc var. Functor (SignatureF loc var)
forall loc var. Foldable (SignatureF loc var)
forall loc var (m :: * -> *) a.
Monad m =>
SignatureF loc var (m a) -> m (SignatureF loc var a)
forall loc var (f :: * -> *) a.
Applicative f =>
SignatureF loc var (f a) -> f (SignatureF loc var a)
forall loc var (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SignatureF loc var a -> m (SignatureF loc var b)
forall loc var (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SignatureF loc var a -> f (SignatureF loc var 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 =>
SignatureF loc var (m a) -> m (SignatureF loc var a)
forall (f :: * -> *) a.
Applicative f =>
SignatureF loc var (f a) -> f (SignatureF loc var a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SignatureF loc var a -> m (SignatureF loc var b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SignatureF loc var a -> f (SignatureF loc var b)
sequence :: SignatureF loc var (m a) -> m (SignatureF loc var a)
$csequence :: forall loc var (m :: * -> *) a.
Monad m =>
SignatureF loc var (m a) -> m (SignatureF loc var a)
mapM :: (a -> m b) -> SignatureF loc var a -> m (SignatureF loc var b)
$cmapM :: forall loc var (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SignatureF loc var a -> m (SignatureF loc var b)
sequenceA :: SignatureF loc var (f a) -> f (SignatureF loc var a)
$csequenceA :: forall loc var (f :: * -> *) a.
Applicative f =>
SignatureF loc var (f a) -> f (SignatureF loc var a)
traverse :: (a -> f b) -> SignatureF loc var a -> f (SignatureF loc var b)
$ctraverse :: forall loc var (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SignatureF loc var a -> f (SignatureF loc var b)
$cp2Traversable :: forall loc var. Foldable (SignatureF loc var)
$cp1Traversable :: forall loc var. Functor (SignatureF loc var)
Traversable, Typeable (SignatureF loc var r)
DataType
Constr
Typeable (SignatureF loc var r)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignatureF loc var r
-> c (SignatureF loc var r))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SignatureF loc var r))
-> (SignatureF loc var r -> Constr)
-> (SignatureF loc var r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SignatureF loc var r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SignatureF loc var r)))
-> ((forall b. Data b => b -> b)
-> SignatureF loc var r -> SignatureF loc var r)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r)
-> (forall u.
(forall d. Data d => d -> u) -> SignatureF loc var r -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> SignatureF loc var r -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r))
-> Data (SignatureF loc var r)
SignatureF loc var r -> DataType
SignatureF loc var r -> Constr
(forall b. Data b => b -> b)
-> SignatureF loc var r -> SignatureF loc var r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignatureF loc var r
-> c (SignatureF loc var r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SignatureF loc var r)
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) -> SignatureF loc var r -> u
forall u.
(forall d. Data d => d -> u) -> SignatureF loc var r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
forall loc var r.
(Data loc, Data var, Data r) =>
Typeable (SignatureF loc var r)
forall loc var r.
(Data loc, Data var, Data r) =>
SignatureF loc var r -> DataType
forall loc var r.
(Data loc, Data var, Data r) =>
SignatureF loc var r -> Constr
forall loc var r.
(Data loc, Data var, Data r) =>
(forall b. Data b => b -> b)
-> SignatureF loc var r -> SignatureF loc var r
forall loc var r u.
(Data loc, Data var, Data r) =>
Int -> (forall d. Data d => d -> u) -> SignatureF loc var r -> u
forall loc var r u.
(Data loc, Data var, Data r) =>
(forall d. Data d => d -> u) -> SignatureF loc var r -> [u]
forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SignatureF loc var r)
forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignatureF loc var r
-> c (SignatureF loc var r)
forall loc var r (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SignatureF loc var r))
forall loc var r (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SignatureF loc var r))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SignatureF loc var r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignatureF loc var r
-> c (SignatureF loc var r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SignatureF loc var r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SignatureF loc var r))
$cMonoT :: Constr
$cForAllT :: Constr
$tSignatureF :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
$cgmapMo :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
gmapMp :: (forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
$cgmapMp :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
gmapM :: (forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
$cgmapM :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> SignatureF loc var r -> m (SignatureF loc var r)
gmapQi :: Int -> (forall d. Data d => d -> u) -> SignatureF loc var r -> u
$cgmapQi :: forall loc var r u.
(Data loc, Data var, Data r) =>
Int -> (forall d. Data d => d -> u) -> SignatureF loc var r -> u
gmapQ :: (forall d. Data d => d -> u) -> SignatureF loc var r -> [u]
$cgmapQ :: forall loc var r u.
(Data loc, Data var, Data r) =>
(forall d. Data d => d -> u) -> SignatureF loc var r -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
$cgmapQr :: forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
$cgmapQl :: forall loc var r r r'.
(Data loc, Data var, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r
gmapT :: (forall b. Data b => b -> b)
-> SignatureF loc var r -> SignatureF loc var r
$cgmapT :: forall loc var r.
(Data loc, Data var, Data r) =>
(forall b. Data b => b -> b)
-> SignatureF loc var r -> SignatureF loc var r
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SignatureF loc var r))
$cdataCast2 :: forall loc var r (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SignatureF loc var r))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (SignatureF loc var r))
$cdataCast1 :: forall loc var r (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SignatureF loc var r))
dataTypeOf :: SignatureF loc var r -> DataType
$cdataTypeOf :: forall loc var r.
(Data loc, Data var, Data r) =>
SignatureF loc var r -> DataType
toConstr :: SignatureF loc var r -> Constr
$ctoConstr :: forall loc var r.
(Data loc, Data var, Data r) =>
SignatureF loc var r -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SignatureF loc var r)
$cgunfold :: forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SignatureF loc var r)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignatureF loc var r
-> c (SignatureF loc var r)
$cgfoldl :: forall loc var r (c :: * -> *).
(Data loc, Data var, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignatureF loc var r
-> c (SignatureF loc var r)
$cp1Data :: forall loc var r.
(Data loc, Data var, Data r) =>
Typeable (SignatureF loc var r)
Data)
$(deriveShow1 ''SignatureF)
$(deriveEq1 ''SignatureF)
$(deriveOrd1 ''SignatureF)
newtype Signature loc var = Signature { Signature loc var -> Fix (SignatureF loc var)
unSignature :: Fix (SignatureF loc var)
} deriving (Int -> Signature loc var -> ShowS
[Signature loc var] -> ShowS
Signature loc var -> String
(Int -> Signature loc var -> ShowS)
-> (Signature loc var -> String)
-> ([Signature loc var] -> ShowS)
-> Show (Signature loc var)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall loc var.
(Show loc, Show var) =>
Int -> Signature loc var -> ShowS
forall loc var.
(Show loc, Show var) =>
[Signature loc var] -> ShowS
forall loc var. (Show loc, Show var) => Signature loc var -> String
showList :: [Signature loc var] -> ShowS
$cshowList :: forall loc var.
(Show loc, Show var) =>
[Signature loc var] -> ShowS
show :: Signature loc var -> String
$cshow :: forall loc var. (Show loc, Show var) => Signature loc var -> String
showsPrec :: Int -> Signature loc var -> ShowS
$cshowsPrec :: forall loc var.
(Show loc, Show var) =>
Int -> Signature loc var -> ShowS
Show, Signature loc var -> Signature loc var -> Bool
(Signature loc var -> Signature loc var -> Bool)
-> (Signature loc var -> Signature loc var -> Bool)
-> Eq (Signature loc var)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc var.
(Eq loc, Eq var) =>
Signature loc var -> Signature loc var -> Bool
/= :: Signature loc var -> Signature loc var -> Bool
$c/= :: forall loc var.
(Eq loc, Eq var) =>
Signature loc var -> Signature loc var -> Bool
== :: Signature loc var -> Signature loc var -> Bool
$c== :: forall loc var.
(Eq loc, Eq var) =>
Signature loc var -> Signature loc var -> Bool
Eq, Eq (Signature loc var)
Eq (Signature loc var)
-> (Signature loc var -> Signature loc var -> Ordering)
-> (Signature loc var -> Signature loc var -> Bool)
-> (Signature loc var -> Signature loc var -> Bool)
-> (Signature loc var -> Signature loc var -> Bool)
-> (Signature loc var -> Signature loc var -> Bool)
-> (Signature loc var -> Signature loc var -> Signature loc var)
-> (Signature loc var -> Signature loc var -> Signature loc var)
-> Ord (Signature loc var)
Signature loc var -> Signature loc var -> Bool
Signature loc var -> Signature loc var -> Ordering
Signature loc var -> Signature loc var -> Signature loc var
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 loc var. (Ord loc, Ord var) => Eq (Signature loc var)
forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Bool
forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Ordering
forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Signature loc var
min :: Signature loc var -> Signature loc var -> Signature loc var
$cmin :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Signature loc var
max :: Signature loc var -> Signature loc var -> Signature loc var
$cmax :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Signature loc var
>= :: Signature loc var -> Signature loc var -> Bool
$c>= :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Bool
> :: Signature loc var -> Signature loc var -> Bool
$c> :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Bool
<= :: Signature loc var -> Signature loc var -> Bool
$c<= :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Bool
< :: Signature loc var -> Signature loc var -> Bool
$c< :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Bool
compare :: Signature loc var -> Signature loc var -> Ordering
$ccompare :: forall loc var.
(Ord loc, Ord var) =>
Signature loc var -> Signature loc var -> Ordering
$cp1Ord :: forall loc var. (Ord loc, Ord var) => Eq (Signature loc var)
Ord, Typeable (Signature loc var)
DataType
Constr
Typeable (Signature loc var)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Signature loc var
-> c (Signature loc var))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Signature loc var))
-> (Signature loc var -> Constr)
-> (Signature loc var -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Signature loc var)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Signature loc var)))
-> ((forall b. Data b => b -> b)
-> Signature loc var -> Signature loc var)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r)
-> (forall u.
(forall d. Data d => d -> u) -> Signature loc var -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> Signature loc var -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var))
-> Data (Signature loc var)
Signature loc var -> DataType
Signature loc var -> Constr
(forall b. Data b => b -> b)
-> Signature loc var -> Signature loc var
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Signature loc var
-> c (Signature loc var)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Signature loc var)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Signature loc var))
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) -> Signature loc var -> u
forall u. (forall d. Data d => d -> u) -> Signature loc var -> [u]
forall loc var.
(Data loc, Data var) =>
Typeable (Signature loc var)
forall loc var.
(Data loc, Data var) =>
Signature loc var -> DataType
forall loc var. (Data loc, Data var) => Signature loc var -> Constr
forall loc var.
(Data loc, Data var) =>
(forall b. Data b => b -> b)
-> Signature loc var -> Signature loc var
forall loc var u.
(Data loc, Data var) =>
Int -> (forall d. Data d => d -> u) -> Signature loc var -> u
forall loc var u.
(Data loc, Data var) =>
(forall d. Data d => d -> u) -> Signature loc var -> [u]
forall loc var r r'.
(Data loc, Data var) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
forall loc var r r'.
(Data loc, Data var) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
forall loc var (m :: * -> *).
(Data loc, Data var, Monad m) =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
forall loc var (m :: * -> *).
(Data loc, Data var, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Signature loc var)
forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Signature loc var
-> c (Signature loc var)
forall loc var (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Signature loc var))
forall loc var (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Signature loc var))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Signature loc var)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Signature loc var
-> c (Signature loc var)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Signature loc var))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Signature loc var))
$cSignature :: Constr
$tSignature :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
$cgmapMo :: forall loc var (m :: * -> *).
(Data loc, Data var, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
gmapMp :: (forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
$cgmapMp :: forall loc var (m :: * -> *).
(Data loc, Data var, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
gmapM :: (forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
$cgmapM :: forall loc var (m :: * -> *).
(Data loc, Data var, Monad m) =>
(forall d. Data d => d -> m d)
-> Signature loc var -> m (Signature loc var)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Signature loc var -> u
$cgmapQi :: forall loc var u.
(Data loc, Data var) =>
Int -> (forall d. Data d => d -> u) -> Signature loc var -> u
gmapQ :: (forall d. Data d => d -> u) -> Signature loc var -> [u]
$cgmapQ :: forall loc var u.
(Data loc, Data var) =>
(forall d. Data d => d -> u) -> Signature loc var -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
$cgmapQr :: forall loc var r r'.
(Data loc, Data var) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
$cgmapQl :: forall loc var r r'.
(Data loc, Data var) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature loc var -> r
gmapT :: (forall b. Data b => b -> b)
-> Signature loc var -> Signature loc var
$cgmapT :: forall loc var.
(Data loc, Data var) =>
(forall b. Data b => b -> b)
-> Signature loc var -> Signature loc var
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Signature loc var))
$cdataCast2 :: forall loc var (t :: * -> * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Signature loc var))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Signature loc var))
$cdataCast1 :: forall loc var (t :: * -> *) (c :: * -> *).
(Data loc, Data var, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Signature loc var))
dataTypeOf :: Signature loc var -> DataType
$cdataTypeOf :: forall loc var.
(Data loc, Data var) =>
Signature loc var -> DataType
toConstr :: Signature loc var -> Constr
$ctoConstr :: forall loc var. (Data loc, Data var) => Signature loc var -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Signature loc var)
$cgunfold :: forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Signature loc var)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Signature loc var
-> c (Signature loc var)
$cgfoldl :: forall loc var (c :: * -> *).
(Data loc, Data var) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Signature loc var
-> c (Signature loc var)
$cp1Data :: forall loc var.
(Data loc, Data var) =>
Typeable (Signature loc var)
Data)
instance Functor (Signature loc) where
fmap :: (a -> b) -> Signature loc a -> Signature loc b
fmap a -> b
f (Signature Fix (SignatureF loc a)
x) = Fix (SignatureF loc b) -> Signature loc b
forall loc var. Fix (SignatureF loc var) -> Signature loc var
Signature (Fix (SignatureF loc b) -> Signature loc b)
-> Fix (SignatureF loc b) -> Signature loc b
forall a b. (a -> b) -> a -> b
$ (SignatureF loc a (Fix (SignatureF loc b))
-> Fix (SignatureF loc b))
-> Fix (SignatureF loc a) -> Fix (SignatureF loc b)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix SignatureF loc a (Fix (SignatureF loc b)) -> Fix (SignatureF loc b)
go Fix (SignatureF loc a)
x
where
go :: SignatureF loc a (Fix (SignatureF loc b)) -> Fix (SignatureF loc b)
go = \case
ForAllT loc
loc a
var Fix (SignatureF loc b)
a -> SignatureF loc b (Fix (SignatureF loc b)) -> Fix (SignatureF loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (SignatureF loc b (Fix (SignatureF loc b))
-> Fix (SignatureF loc b))
-> SignatureF loc b (Fix (SignatureF loc b))
-> Fix (SignatureF loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> b
-> Fix (SignatureF loc b)
-> SignatureF loc b (Fix (SignatureF loc b))
forall loc var r. loc -> var -> r -> SignatureF loc var r
ForAllT loc
loc (a -> b
f a
var) Fix (SignatureF loc b)
a
MonoT Type loc a
ty -> SignatureF loc b (Fix (SignatureF loc b)) -> Fix (SignatureF loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (SignatureF loc b (Fix (SignatureF loc b))
-> Fix (SignatureF loc b))
-> SignatureF loc b (Fix (SignatureF loc b))
-> Fix (SignatureF loc b)
forall a b. (a -> b) -> a -> b
$ Type loc b -> SignatureF loc b (Fix (SignatureF loc b))
forall loc var r. Type loc var -> SignatureF loc var r
MonoT (Type loc b -> SignatureF loc b (Fix (SignatureF loc b)))
-> Type loc b -> SignatureF loc b (Fix (SignatureF loc b))
forall a b. (a -> b) -> a -> b
$ (a -> b) -> Type loc a -> Type loc b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Type loc a
ty
instance Functor (Type a) where
fmap :: (a -> b) -> Type a a -> Type a b
fmap a -> b
f (Type Fix (TypeF a a)
x) = Fix (TypeF a b) -> Type a b
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF a b) -> Type a b) -> Fix (TypeF a b) -> Type a b
forall a b. (a -> b) -> a -> b
$ (TypeF a a (Fix (TypeF a b)) -> Fix (TypeF a b))
-> Fix (TypeF a a) -> Fix (TypeF a b)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TypeF a a (Fix (TypeF a b)) -> Fix (TypeF a b)
go Fix (TypeF a a)
x
where
go :: TypeF a a (Fix (TypeF a b)) -> Fix (TypeF a b)
go = \case
VarT a
loc a
name -> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b))
-> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall a b. (a -> b) -> a -> b
$ a -> b -> TypeF a b (Fix (TypeF a b))
forall loc var r. loc -> var -> TypeF loc var r
VarT a
loc (b -> TypeF a b (Fix (TypeF a b)))
-> b -> TypeF a b (Fix (TypeF a b))
forall a b. (a -> b) -> a -> b
$ a -> b
f a
name
ConT a
loc a
name [Fix (TypeF a b)]
args -> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b))
-> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall a b. (a -> b) -> a -> b
$ a -> b -> [Fix (TypeF a b)] -> TypeF a b (Fix (TypeF a b))
forall loc var r. loc -> var -> [r] -> TypeF loc var r
ConT a
loc (a -> b
f a
name) [Fix (TypeF a b)]
args
ArrowT a
loc Fix (TypeF a b)
a Fix (TypeF a b)
b -> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b))
-> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall a b. (a -> b) -> a -> b
$ a
-> Fix (TypeF a b)
-> Fix (TypeF a b)
-> TypeF a b (Fix (TypeF a b))
forall loc var r. loc -> r -> r -> TypeF loc var r
ArrowT a
loc Fix (TypeF a b)
a Fix (TypeF a b)
b
TupleT a
loc [Fix (TypeF a b)]
as -> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b))
-> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall a b. (a -> b) -> a -> b
$ a -> [Fix (TypeF a b)] -> TypeF a b (Fix (TypeF a b))
forall loc var r. loc -> [r] -> TypeF loc var r
TupleT a
loc [Fix (TypeF a b)]
as
ListT a
loc Fix (TypeF a b)
a -> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b))
-> TypeF a b (Fix (TypeF a b)) -> Fix (TypeF a b)
forall a b. (a -> b) -> a -> b
$ a -> Fix (TypeF a b) -> TypeF a b (Fix (TypeF a b))
forall loc var r. loc -> r -> TypeF loc var r
ListT a
loc Fix (TypeF a b)
a
instance HasLoc (Signature loc var) where
type Loc (Signature loc var) = loc
getLoc :: Signature loc var -> Loc (Signature loc var)
getLoc (Signature Fix (SignatureF loc var)
x) = (SignatureF loc var loc -> loc) -> Fix (SignatureF loc var) -> loc
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix SignatureF loc var loc -> loc
forall p var r. SignatureF p var r -> p
go Fix (SignatureF loc var)
x
where
go :: SignatureF p var r -> p
go = \case
MonoT Type p var
ty -> Type p var -> Loc (Type p var)
forall f. HasLoc f => f -> Loc f
getLoc Type p var
ty
ForAllT p
loc var
_ r
_ -> p
loc
class LocFunctor f where
mapLoc :: (locA -> locB) -> f locA var -> f locB var
setLoc :: LocFunctor f => loc -> f locA v -> f loc v
setLoc :: loc -> f locA v -> f loc v
setLoc loc
loc = (locA -> loc) -> f locA v -> f loc v
forall (f :: * -> * -> *) locA locB var.
LocFunctor f =>
(locA -> locB) -> f locA var -> f locB var
mapLoc (loc -> locA -> loc
forall a b. a -> b -> a
const loc
loc)
instance LocFunctor Type where
mapLoc :: (locA -> locB) -> Type locA var -> Type locB var
mapLoc locA -> locB
f (Type Fix (TypeF locA var)
x) = Fix (TypeF locB var) -> Type locB var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type (Fix (TypeF locB var) -> Type locB var)
-> Fix (TypeF locB var) -> Type locB var
forall a b. (a -> b) -> a -> b
$ (TypeF locA var (Fix (TypeF locB var)) -> Fix (TypeF locB var))
-> Fix (TypeF locA var) -> Fix (TypeF locB var)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TypeF locA var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
go Fix (TypeF locA var)
x
where
go :: TypeF locA var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
go = \case
VarT locA
loc var
name -> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var))
-> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall a b. (a -> b) -> a -> b
$ locB -> var -> TypeF locB var (Fix (TypeF locB var))
forall loc var r. loc -> var -> TypeF loc var r
VarT (locA -> locB
f locA
loc) var
name
ConT locA
loc var
name [Fix (TypeF locB var)]
args -> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var))
-> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> var
-> [Fix (TypeF locB var)]
-> TypeF locB var (Fix (TypeF locB var))
forall loc var r. loc -> var -> [r] -> TypeF loc var r
ConT (locA -> locB
f locA
loc) var
name [Fix (TypeF locB var)]
args
ArrowT locA
loc Fix (TypeF locB var)
a Fix (TypeF locB var)
b -> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var))
-> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Fix (TypeF locB var)
-> Fix (TypeF locB var)
-> TypeF locB var (Fix (TypeF locB var))
forall loc var r. loc -> r -> r -> TypeF loc var r
ArrowT (locA -> locB
f locA
loc) Fix (TypeF locB var)
a Fix (TypeF locB var)
b
TupleT locA
loc [Fix (TypeF locB var)]
as -> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var))
-> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> [Fix (TypeF locB var)] -> TypeF locB var (Fix (TypeF locB var))
forall loc var r. loc -> [r] -> TypeF loc var r
TupleT (locA -> locB
f locA
loc) [Fix (TypeF locB var)]
as
ListT locA
loc Fix (TypeF locB var)
a -> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var))
-> TypeF locB var (Fix (TypeF locB var)) -> Fix (TypeF locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Fix (TypeF locB var) -> TypeF locB var (Fix (TypeF locB var))
forall loc var r. loc -> r -> TypeF loc var r
ListT (locA -> locB
f locA
loc) Fix (TypeF locB var)
a
instance LocFunctor Signature where
mapLoc :: (locA -> locB) -> Signature locA var -> Signature locB var
mapLoc locA -> locB
f (Signature Fix (SignatureF locA var)
x) = Fix (SignatureF locB var) -> Signature locB var
forall loc var. Fix (SignatureF loc var) -> Signature loc var
Signature (Fix (SignatureF locB var) -> Signature locB var)
-> Fix (SignatureF locB var) -> Signature locB var
forall a b. (a -> b) -> a -> b
$ (SignatureF locA var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var))
-> Fix (SignatureF locA var) -> Fix (SignatureF locB var)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix SignatureF locA var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var)
go Fix (SignatureF locA var)
x
where
go :: SignatureF locA var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var)
go = \case
ForAllT locA
loc var
var Fix (SignatureF locB var)
a -> SignatureF locB var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (SignatureF locB var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var))
-> SignatureF locB var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> var
-> Fix (SignatureF locB var)
-> SignatureF locB var (Fix (SignatureF locB var))
forall loc var r. loc -> var -> r -> SignatureF loc var r
ForAllT (locA -> locB
f locA
loc) var
var Fix (SignatureF locB var)
a
MonoT Type locA var
ty -> SignatureF locB var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (SignatureF locB var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var))
-> SignatureF locB var (Fix (SignatureF locB var))
-> Fix (SignatureF locB var)
forall a b. (a -> b) -> a -> b
$ Type locB var -> SignatureF locB var (Fix (SignatureF locB var))
forall loc var r. Type loc var -> SignatureF loc var r
MonoT (Type locB var -> SignatureF locB var (Fix (SignatureF locB var)))
-> Type locB var -> SignatureF locB var (Fix (SignatureF locB var))
forall a b. (a -> b) -> a -> b
$ (locA -> locB) -> Type locA var -> Type locB var
forall (f :: * -> * -> *) locA locB var.
LocFunctor f =>
(locA -> locB) -> f locA var -> f locB var
mapLoc locA -> locB
f Type locA var
ty
class TypeFunctor f where
mapType :: (Type loc var -> Type loc var) -> f loc var -> f loc var
instance TypeFunctor Type where
mapType :: (Type loc var -> Type loc var) -> Type loc var -> Type loc var
mapType Type loc var -> Type loc var
f = Type loc var -> Type loc var
f
forAllT :: loc -> v -> Signature loc v -> Signature loc v
forAllT :: loc -> v -> Signature loc v -> Signature loc v
forAllT loc
loc v
x (Signature Fix (SignatureF loc v)
t) = Fix (SignatureF loc v) -> Signature loc v
forall loc var. Fix (SignatureF loc var) -> Signature loc var
Signature (Fix (SignatureF loc v) -> Signature loc v)
-> Fix (SignatureF loc v) -> Signature loc v
forall a b. (a -> b) -> a -> b
$ SignatureF loc v (Fix (SignatureF loc v)) -> Fix (SignatureF loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (SignatureF loc v (Fix (SignatureF loc v))
-> Fix (SignatureF loc v))
-> SignatureF loc v (Fix (SignatureF loc v))
-> Fix (SignatureF loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> v
-> Fix (SignatureF loc v)
-> SignatureF loc v (Fix (SignatureF loc v))
forall loc var r. loc -> var -> r -> SignatureF loc var r
ForAllT loc
loc v
x Fix (SignatureF loc v)
t
monoT :: Type loc src -> Signature loc src
monoT :: Type loc src -> Signature loc src
monoT = Fix (SignatureF loc src) -> Signature loc src
forall loc var. Fix (SignatureF loc var) -> Signature loc var
Signature (Fix (SignatureF loc src) -> Signature loc src)
-> (Type loc src -> Fix (SignatureF loc src))
-> Type loc src
-> Signature loc src
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignatureF loc src (Fix (SignatureF loc src))
-> Fix (SignatureF loc src)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (SignatureF loc src (Fix (SignatureF loc src))
-> Fix (SignatureF loc src))
-> (Type loc src -> SignatureF loc src (Fix (SignatureF loc src)))
-> Type loc src
-> Fix (SignatureF loc src)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type loc src -> SignatureF loc src (Fix (SignatureF loc src))
forall loc var r. Type loc var -> SignatureF loc var r
MonoT
typeToSignature :: (Eq loc, Ord v) => Type loc v -> Signature loc v
typeToSignature :: Type loc v -> Signature loc v
typeToSignature Type loc v
ty = ((v, loc) -> Signature loc v -> Signature loc v)
-> Signature loc v -> [(v, loc)] -> Signature loc v
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(v
v, loc
src) Signature loc v
a -> loc -> v -> Signature loc v -> Signature loc v
forall loc v. loc -> v -> Signature loc v -> Signature loc v
forAllT loc
src v
v Signature loc v
a) (Type loc v -> Signature loc v
forall loc src. Type loc src -> Signature loc src
monoT Type loc v
ty) [(v, loc)]
vs
where
vs :: [(v, loc)]
vs = Type loc v -> [(v, loc)]
forall (f :: * -> * -> *) src var.
(HasTypeVars f, Eq src, Ord var) =>
f src var -> [(var, src)]
tyVarsInOrder Type loc v
ty
getTypeVars :: (Ord var, HasTypeVars f) => f src var -> [(src, var)]
getTypeVars :: f src var -> [(src, var)]
getTypeVars = VarSet src var -> [(src, var)]
forall src var. VarSet src var -> [(src, var)]
varSetToList (VarSet src var -> [(src, var)])
-> (f src var -> VarSet src var) -> f src var -> [(src, var)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f src var -> VarSet src var
forall (f :: * -> * -> *) var src.
(HasTypeVars f, Ord var) =>
f src var -> VarSet src var
tyVars
class HasTypeVars f where
tyVars :: Ord var => f src var -> VarSet src var
tyVarsInOrder :: (Eq src, Ord var) => f src var -> [(var, src)]
instance HasTypeVars Type where
tyVars :: Type src var -> VarSet src var
tyVars = (TypeF src var (VarSet src var) -> VarSet src var)
-> Fix (TypeF src var) -> VarSet src var
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TypeF src var (VarSet src var) -> VarSet src var
forall src. TypeF src var (VarSet src var) -> VarSet src var
go (Fix (TypeF src var) -> VarSet src var)
-> (Type src var -> Fix (TypeF src var))
-> Type src var
-> VarSet src var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type src var -> Fix (TypeF src var)
forall loc var. Type loc var -> Fix (TypeF loc var)
unType
where
go :: TypeF src var (VarSet src var) -> VarSet src var
go = \case
VarT src
loc var
v -> Map var src -> VarSet src var
forall src var. Map var src -> VarSet src var
VarSet (Map var src -> VarSet src var) -> Map var src -> VarSet src var
forall a b. (a -> b) -> a -> b
$ var -> src -> Map var src
forall k a. k -> a -> Map k a
M.singleton var
v src
loc
ConT src
_ var
_ [VarSet src var]
args -> [VarSet src var] -> VarSet src var
forall a. Monoid a => [a] -> a
mconcat [VarSet src var]
args
ArrowT src
_ VarSet src var
a VarSet src var
b -> VarSet src var -> VarSet src var -> VarSet src var
forall a. Monoid a => a -> a -> a
mappend VarSet src var
a VarSet src var
b
TupleT src
_ [VarSet src var]
as -> [VarSet src var] -> VarSet src var
forall a. Monoid a => [a] -> a
mconcat [VarSet src var]
as
ListT src
_ VarSet src var
a -> VarSet src var
a
tyVarsInOrder :: Type src var -> [(var, src)]
tyVarsInOrder = ((var, src) -> var) -> [(var, src)] -> [(var, src)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
nubOrdOn (var, src) -> var
forall a b. (a, b) -> a
fst ([(var, src)] -> [(var, src)])
-> (Type src var -> [(var, src)]) -> Type src var -> [(var, src)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TypeF src var [(var, src)] -> [(var, src)])
-> Fix (TypeF src var) -> [(var, src)]
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TypeF src var [(var, src)] -> [(var, src)]
forall b a. TypeF b a [(a, b)] -> [(a, b)]
go (Fix (TypeF src var) -> [(var, src)])
-> (Type src var -> Fix (TypeF src var))
-> Type src var
-> [(var, src)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type src var -> Fix (TypeF src var)
forall loc var. Type loc var -> Fix (TypeF loc var)
unType
where
go :: TypeF b a [(a, b)] -> [(a, b)]
go = \case
VarT b
loc a
var -> [(a
var, b
loc)]
ConT b
_ a
_ [[(a, b)]]
as -> [[(a, b)]] -> [(a, b)]
forall a. Monoid a => [a] -> a
mconcat [[(a, b)]]
as
ArrowT b
_ [(a, b)]
a [(a, b)]
b -> [(a, b)] -> [(a, b)] -> [(a, b)]
forall a. Monoid a => a -> a -> a
mappend [(a, b)]
a [(a, b)]
b
TupleT b
_ [[(a, b)]]
as -> [[(a, b)]] -> [(a, b)]
forall a. Monoid a => [a] -> a
mconcat [[(a, b)]]
as
ListT b
_ [(a, b)]
a -> [(a, b)]
a
instance HasTypeVars Signature where
tyVars :: Signature src var -> VarSet src var
tyVars = (SignatureF src var (VarSet src var) -> VarSet src var)
-> Fix (SignatureF src var) -> VarSet src var
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix SignatureF src var (VarSet src var) -> VarSet src var
forall src. SignatureF src var (VarSet src var) -> VarSet src var
go (Fix (SignatureF src var) -> VarSet src var)
-> (Signature src var -> Fix (SignatureF src var))
-> Signature src var
-> VarSet src var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signature src var -> Fix (SignatureF src var)
forall loc var. Signature loc var -> Fix (SignatureF loc var)
unSignature
where
go :: SignatureF src var (VarSet src var) -> VarSet src var
go = \case
MonoT Type src var
t -> Type src var -> VarSet src var
forall (f :: * -> * -> *) var src.
(HasTypeVars f, Ord var) =>
f src var -> VarSet src var
tyVars Type src var
t
ForAllT src
_ var
x VarSet src var
t -> Map var src -> VarSet src var
forall src var. Map var src -> VarSet src var
VarSet (Map var src -> VarSet src var) -> Map var src -> VarSet src var
forall a b. (a -> b) -> a -> b
$ var -> Map var src -> Map var src
forall k a. Ord k => k -> Map k a -> Map k a
M.delete var
x (Map var src -> Map var src) -> Map var src -> Map var src
forall a b. (a -> b) -> a -> b
$ VarSet src var -> Map var src
forall src var. VarSet src var -> Map var src
unVarSet VarSet src var
t
tyVarsInOrder :: Signature src var -> [(var, src)]
tyVarsInOrder = ((var, src) -> var) -> [(var, src)] -> [(var, src)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
nubOrdOn (var, src) -> var
forall a b. (a, b) -> a
fst ([(var, src)] -> [(var, src)])
-> (Signature src var -> [(var, src)])
-> Signature src var
-> [(var, src)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SignatureF src var [(var, src)] -> [(var, src)])
-> Fix (SignatureF src var) -> [(var, src)]
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix SignatureF src var [(var, src)] -> [(var, src)]
go (Fix (SignatureF src var) -> [(var, src)])
-> (Signature src var -> Fix (SignatureF src var))
-> Signature src var
-> [(var, src)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signature src var -> Fix (SignatureF src var)
forall loc var. Signature loc var -> Fix (SignatureF loc var)
unSignature
where
go :: SignatureF src var [(var, src)] -> [(var, src)]
go = \case
MonoT Type src var
t -> Type src var -> [(var, src)]
forall (f :: * -> * -> *) src var.
(HasTypeVars f, Eq src, Ord var) =>
f src var -> [(var, src)]
tyVarsInOrder Type src var
t
ForAllT src
src var
x [(var, src)]
t -> ((var, src) -> (var, src) -> Bool)
-> (var, src) -> [(var, src)] -> [(var, src)]
forall a. (a -> a -> Bool) -> a -> [a] -> [a]
L.deleteBy (var -> var -> Bool
forall a. Eq a => a -> a -> Bool
(==) (var -> var -> Bool)
-> ((var, src) -> var) -> (var, src) -> (var, src) -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (var, src) -> var
forall a b. (a, b) -> a
fst) (var
x, src
src) [(var, src)]
t
newtype VarSet src var = VarSet { VarSet src var -> Map var src
unVarSet :: Map var src }
deriving (b -> VarSet src var -> VarSet src var
NonEmpty (VarSet src var) -> VarSet src var
VarSet src var -> VarSet src var -> VarSet src var
(VarSet src var -> VarSet src var -> VarSet src var)
-> (NonEmpty (VarSet src var) -> VarSet src var)
-> (forall b. Integral b => b -> VarSet src var -> VarSet src var)
-> Semigroup (VarSet src var)
forall b. Integral b => b -> VarSet src var -> VarSet src var
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall src var.
Ord var =>
NonEmpty (VarSet src var) -> VarSet src var
forall src var.
Ord var =>
VarSet src var -> VarSet src var -> VarSet src var
forall src var b.
(Ord var, Integral b) =>
b -> VarSet src var -> VarSet src var
stimes :: b -> VarSet src var -> VarSet src var
$cstimes :: forall src var b.
(Ord var, Integral b) =>
b -> VarSet src var -> VarSet src var
sconcat :: NonEmpty (VarSet src var) -> VarSet src var
$csconcat :: forall src var.
Ord var =>
NonEmpty (VarSet src var) -> VarSet src var
<> :: VarSet src var -> VarSet src var -> VarSet src var
$c<> :: forall src var.
Ord var =>
VarSet src var -> VarSet src var -> VarSet src var
Semigroup, Semigroup (VarSet src var)
VarSet src var
Semigroup (VarSet src var)
-> VarSet src var
-> (VarSet src var -> VarSet src var -> VarSet src var)
-> ([VarSet src var] -> VarSet src var)
-> Monoid (VarSet src var)
[VarSet src var] -> VarSet src var
VarSet src var -> VarSet src var -> VarSet src var
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall src var. Ord var => Semigroup (VarSet src var)
forall src var. Ord var => VarSet src var
forall src var. Ord var => [VarSet src var] -> VarSet src var
forall src var.
Ord var =>
VarSet src var -> VarSet src var -> VarSet src var
mconcat :: [VarSet src var] -> VarSet src var
$cmconcat :: forall src var. Ord var => [VarSet src var] -> VarSet src var
mappend :: VarSet src var -> VarSet src var -> VarSet src var
$cmappend :: forall src var.
Ord var =>
VarSet src var -> VarSet src var -> VarSet src var
mempty :: VarSet src var
$cmempty :: forall src var. Ord var => VarSet src var
$cp1Monoid :: forall src var. Ord var => Semigroup (VarSet src var)
Monoid)
differenceVarSet :: Ord var => VarSet src var -> VarSet src var -> VarSet src var
differenceVarSet :: VarSet src var -> VarSet src var -> VarSet src var
differenceVarSet (VarSet Map var src
a) (VarSet Map var src
b) = Map var src -> VarSet src var
forall src var. Map var src -> VarSet src var
VarSet (Map var src -> VarSet src var) -> Map var src -> VarSet src var
forall a b. (a -> b) -> a -> b
$ Map var src
a Map var src -> Map var src -> Map var src
forall k a b. Ord k => Map k a -> Map k b -> Map k a
`M.difference` Map var src
b
varSetToList :: VarSet src var -> [(src, var)]
varSetToList :: VarSet src var -> [(src, var)]
varSetToList (VarSet Map var src
m) = ((var, src) -> (src, var)) -> [(var, src)] -> [(src, var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (var, src) -> (src, var)
forall a b. (a, b) -> (b, a)
swap ([(var, src)] -> [(src, var)]) -> [(var, src)] -> [(src, var)]
forall a b. (a -> b) -> a -> b
$ Map var src -> [(var, src)]
forall k a. Map k a -> [(k, a)]
M.toList Map var src
m
memberVarSet :: Ord var => var -> VarSet src var -> Bool
memberVarSet :: var -> VarSet src var -> Bool
memberVarSet var
k (VarSet Map var src
m) = var -> Map var src -> Bool
forall k a. Ord k => k -> Map k a -> Bool
M.member var
k Map var src
m
stripSignature :: Signature src var -> Type src var
stripSignature :: Signature src var -> Type src var
stripSignature = (SignatureF src var (Type src var) -> Type src var)
-> Fix (SignatureF src var) -> Type src var
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix SignatureF src var (Type src var) -> Type src var
forall loc var. SignatureF loc var (Type loc var) -> Type loc var
go (Fix (SignatureF src var) -> Type src var)
-> (Signature src var -> Fix (SignatureF src var))
-> Signature src var
-> Type src var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signature src var -> Fix (SignatureF src var)
forall loc var. Signature loc var -> Fix (SignatureF loc var)
unSignature
where
go :: SignatureF loc var (Type loc var) -> Type loc var
go = \case
ForAllT loc
_ var
_ Type loc var
r -> Type loc var
r
MonoT Type loc var
ty -> Type loc var
ty
splitSignature :: Signature loc var -> ([var], Type loc var)
splitSignature :: Signature loc var -> ([var], Type loc var)
splitSignature (Signature Fix (SignatureF loc var)
x) = ((SignatureF loc var ([var], Type loc var)
-> ([var], Type loc var))
-> Fix (SignatureF loc var) -> ([var], Type loc var))
-> Fix (SignatureF loc var)
-> (SignatureF loc var ([var], Type loc var)
-> ([var], Type loc var))
-> ([var], Type loc var)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (SignatureF loc var ([var], Type loc var) -> ([var], Type loc var))
-> Fix (SignatureF loc var) -> ([var], Type loc var)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix Fix (SignatureF loc var)
x ((SignatureF loc var ([var], Type loc var)
-> ([var], Type loc var))
-> ([var], Type loc var))
-> (SignatureF loc var ([var], Type loc var)
-> ([var], Type loc var))
-> ([var], Type loc var)
forall a b. (a -> b) -> a -> b
$ \case
ForAllT loc
_ var
v ([var]
vs, Type loc var
t) -> (var
vvar -> [var] -> [var]
forall a. a -> [a] -> [a]
:[var]
vs, Type loc var
t)
MonoT Type loc var
t -> ([], Type loc var
t)
extractFunType :: Type loc var -> ([Type loc var], Type loc var)
Type loc var
ty = case Type loc var -> Maybe (Type loc var, Type loc var)
forall loc var. Type loc var -> Maybe (Type loc var, Type loc var)
extractArrow Type loc var
ty of
Just (Type loc var
lhs, Type loc var
rhs) ->
let ([Type loc var]
args, Type loc var
rhs') = Type loc var -> ([Type loc var], Type loc var)
forall loc var. Type loc var -> ([Type loc var], Type loc var)
extractFunType Type loc var
rhs
in (Type loc var
lhs Type loc var -> [Type loc var] -> [Type loc var]
forall a. a -> [a] -> [a]
: [Type loc var]
args, Type loc var
rhs')
Maybe (Type loc var, Type loc var)
Nothing -> ([], Type loc var
ty)
extractArrow :: Type loc var -> Maybe (Type loc var, Type loc var)
(Type (Fix TypeF loc var (Fix (TypeF loc var))
x)) = case TypeF loc var (Fix (TypeF loc var))
x of
ArrowT loc
_ Fix (TypeF loc var)
a Fix (TypeF loc var)
b -> (Type loc var, Type loc var) -> Maybe (Type loc var, Type loc var)
forall a. a -> Maybe a
Just (Fix (TypeF loc var) -> Type loc var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type Fix (TypeF loc var)
a, Fix (TypeF loc var) -> Type loc var
forall loc var. Fix (TypeF loc var) -> Type loc var
Type Fix (TypeF loc var)
b)
TypeF loc var (Fix (TypeF loc var))
_ -> Maybe (Type loc var, Type loc var)
forall a. Maybe a
Nothing
isMono :: Type loc var -> Bool
isMono :: Type loc var -> Bool
isMono (Type Fix (TypeF loc var)
t) = All -> Bool
getAll (All -> Bool) -> All -> Bool
forall a b. (a -> b) -> a -> b
$ ((TypeF loc var All -> All) -> Fix (TypeF loc var) -> All)
-> Fix (TypeF loc var) -> (TypeF loc var All -> All) -> All
forall a b c. (a -> b -> c) -> b -> a -> c
flip (TypeF loc var All -> All) -> Fix (TypeF loc var) -> All
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix Fix (TypeF loc var)
t ((TypeF loc var All -> All) -> All)
-> (TypeF loc var All -> All) -> All
forall a b. (a -> b) -> a -> b
$ \case
VarT loc
_ var
_ -> Bool -> All
All Bool
False
TypeF loc var All
other -> TypeF loc var All -> All
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold TypeF loc var All
other
isPoly :: Type loc var -> Bool
isPoly :: Type loc var -> Bool
isPoly = Bool -> Bool
not (Bool -> Bool) -> (Type loc var -> Bool) -> Type loc var -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type loc var -> Bool
forall loc var. Type loc var -> Bool
isMono