-- | This module contains the abstract syntax of Hindley-Milner types.
module Type.Check.HM.Type (
    IsVar(..),
    HasLoc(..),
    DefLoc(..),
    -- * Monomorphic types.
    TypeF(..),
    Type(..),
    varT,
    conT,
    arrowT,
    tupleT,
    listT,
    -- * Typed values
    Typed(..),

    -- * Polymorphic types.
    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 to get source code location.
class HasLoc f where
  -- | Type for source code location
  type Loc f :: *

  -- | Get the source code location.
  getLoc :: f -> Loc f

-- | Type class for default location
class DefLoc f where
  defLoc :: f

-- | Functions we need for variables to do type-inference.
class (Show v, Ord v) => IsVar v where
  -- | Canonical leters for pretty output
  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 = ()

-- | Type functor. Arguments are
--
-- * @loc@ - source code locations
--
-- * @var@ - variable name
--
-- * @r@ - recursion
--
-- There are only two requried constructors: @VarT@ and @ConT@
-- other constructors are used for convenience of pretty-printing the type.
data TypeF loc var r
    = VarT loc var      -- ^ Variables
    | ConT loc var [r]  -- ^ type constant with list of arguments
    | ArrowT loc r r    -- ^ Special case of ConT that is rendered as ->
    | TupleT loc [r]    -- ^ Special case of ConT that is rendered as (,,,)
    | ListT loc r       -- ^ Special case of ConT that is rendered as [a]
    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)

-- | Values that are tagged explicitly with their type.
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)

-- | Monomorphic types.
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 x@ constructs a type variable named @x@ with source code at @loc@.
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 x@ constructs a type constant named @x@ with source code at @loc@.
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 t0 t1@ constructs an arrow type from @t0@ to @t1@ with source code at @loc@.
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 ts@ constructs tuple of types @ts@ with source code at @loc@.
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 t@ constructs list of @t@ with source code at @loc@.
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

--------------------------------------------------------------------------------

-- | Functor for signature is a special type that we need for type inference algorithm.
-- We specify which variables in the type are schematic (non-free).
data SignatureF loc var r
    = ForAllT loc var r     -- ^ specify schematic variable
    | MonoT (Type loc var)  -- ^ contains the type
    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)

-- | Signaure is a special type that we need for type inference algorithm.
-- We specify which variables in the type are schematic (non-free).
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

-- | Mapping over source code locations. It's like functor but for source code locations.
class LocFunctor f where
  mapLoc :: (locA -> locB) -> f locA var -> f locB var

-- | Sets the source code location to given value for all expressions in the functor.
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

-- | Mapps over all types that are contained in the value
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' @x t@ universally quantifies @x@ in @t@.
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' @t@ lifts a monomorophic type @t@ to a polymorphic one.
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

-- | Converts simple type to signature with all free variables set to schematic.
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

-- | Reads all type-variables.
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

--------------------------------------------------------------------------------

-- | The class of types which have free type variables.
class HasTypeVars f where
    -- | 'tyVars' @t@ calculates the set of free type variables in @t@.
    tyVars :: Ord var => f src var -> VarSet src var

    -- | 'tyVarsInOrder' @t@ is like 'tyVars' @t@, except that the type
    -- variables are returned in the order in which they are encountered.
    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

--------------------------------------------------------------------------------

-- | Set with information on source code locations.
-- We use it to keep the source code locations for variables.
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)

-- | 'difference' for @VarSet@'s
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

-- | Converts varset to list.
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

-- | Checks membership of the item in the varset.
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

--------------------------------------------------------------------------------

-- | Removes all information on variables in the type.
-- it gets the thing that we store in constructor @MonoT@.
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

-- | Separates type variables from type definition.
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)

-- | If underlying type is a function with several arguments it extracts its list of arguments and result type.
extractFunType :: Type loc var -> ([Type loc var], Type loc var)
extractFunType :: Type loc var -> ([Type loc var], Type loc var)
extractFunType 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)

-- | If underlying type is an arrow it extracts its single argument and result type.
extractArrow :: Type loc var -> Maybe (Type loc var, Type loc var)
extractArrow :: Type loc var -> Maybe (Type loc var, Type loc var)
extractArrow (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

------------------------------------

-- | Checks that type is monomorphic.
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

-- | Checks that type is polymorphic.
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