-- | This module contains the abstract syntax tree of the term language.
module Type.Check.HM.Term(
    Term(..)
  , TermF(..)
  , CaseAlt(..)
  , Bind(..)
  , varE
  , primE
  , appE
  , lamE
  , letE
  , letRecE
  , assertTypeE
  , caseE
  , constrE
  , bottomE
  , freeVars
) where

import Control.Arrow

import Data.Data
import Data.Fix
import Data.Set (Set)
import Data.Eq.Deriving
import Data.Ord.Deriving
import Text.Show.Deriving

import Type.Check.HM.Subst
import Type.Check.HM.Type

import qualified Data.Set as S

-- | Term functor. The arguments are
-- @loc@ for source code locations, @v@ for variables, @r@ for recurion.
data TermF prim loc v r
    = Var loc v                       -- ^ Variables.
    | Prim loc prim                   -- ^ Primitives.
    | App loc r r                     -- ^ Applications.
    | Lam loc v r                     -- ^ Abstractions.
    | Let loc (Bind loc v r) r        -- ^ Let bindings.
    | LetRec loc [Bind loc v r] r     -- ^ Recursive  let bindings
    | AssertType loc r (Type loc v)   -- ^ Assert type.
    | Case loc r [CaseAlt loc v r]    -- ^ case alternatives
    | Constr loc (Type loc v) v       -- ^ constructor with tag and arity, also we should provide the type
                                      --   of constructor as a function for a type-checker
    | Bottom loc                      -- ^ value of any type that means failed program.
    deriving (Int -> TermF prim loc v r -> ShowS
[TermF prim loc v r] -> ShowS
TermF prim loc v r -> String
(Int -> TermF prim loc v r -> ShowS)
-> (TermF prim loc v r -> String)
-> ([TermF prim loc v r] -> ShowS)
-> Show (TermF prim loc v r)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall prim loc v r.
(Show loc, Show v, Show prim, Show r) =>
Int -> TermF prim loc v r -> ShowS
forall prim loc v r.
(Show loc, Show v, Show prim, Show r) =>
[TermF prim loc v r] -> ShowS
forall prim loc v r.
(Show loc, Show v, Show prim, Show r) =>
TermF prim loc v r -> String
showList :: [TermF prim loc v r] -> ShowS
$cshowList :: forall prim loc v r.
(Show loc, Show v, Show prim, Show r) =>
[TermF prim loc v r] -> ShowS
show :: TermF prim loc v r -> String
$cshow :: forall prim loc v r.
(Show loc, Show v, Show prim, Show r) =>
TermF prim loc v r -> String
showsPrec :: Int -> TermF prim loc v r -> ShowS
$cshowsPrec :: forall prim loc v r.
(Show loc, Show v, Show prim, Show r) =>
Int -> TermF prim loc v r -> ShowS
Show, TermF prim loc v r -> TermF prim loc v r -> Bool
(TermF prim loc v r -> TermF prim loc v r -> Bool)
-> (TermF prim loc v r -> TermF prim loc v r -> Bool)
-> Eq (TermF prim loc v r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall prim loc v r.
(Eq loc, Eq v, Eq prim, Eq r) =>
TermF prim loc v r -> TermF prim loc v r -> Bool
/= :: TermF prim loc v r -> TermF prim loc v r -> Bool
$c/= :: forall prim loc v r.
(Eq loc, Eq v, Eq prim, Eq r) =>
TermF prim loc v r -> TermF prim loc v r -> Bool
== :: TermF prim loc v r -> TermF prim loc v r -> Bool
$c== :: forall prim loc v r.
(Eq loc, Eq v, Eq prim, Eq r) =>
TermF prim loc v r -> TermF prim loc v r -> Bool
Eq, a -> TermF prim loc v b -> TermF prim loc v a
(a -> b) -> TermF prim loc v a -> TermF prim loc v b
(forall a b. (a -> b) -> TermF prim loc v a -> TermF prim loc v b)
-> (forall a b. a -> TermF prim loc v b -> TermF prim loc v a)
-> Functor (TermF prim loc v)
forall a b. a -> TermF prim loc v b -> TermF prim loc v a
forall a b. (a -> b) -> TermF prim loc v a -> TermF prim loc v b
forall prim loc v a b.
a -> TermF prim loc v b -> TermF prim loc v a
forall prim loc v a b.
(a -> b) -> TermF prim loc v a -> TermF prim 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 -> TermF prim loc v b -> TermF prim loc v a
$c<$ :: forall prim loc v a b.
a -> TermF prim loc v b -> TermF prim loc v a
fmap :: (a -> b) -> TermF prim loc v a -> TermF prim loc v b
$cfmap :: forall prim loc v a b.
(a -> b) -> TermF prim loc v a -> TermF prim loc v b
Functor, TermF prim loc v a -> Bool
(a -> m) -> TermF prim loc v a -> m
(a -> b -> b) -> b -> TermF prim loc v a -> b
(forall m. Monoid m => TermF prim loc v m -> m)
-> (forall m a. Monoid m => (a -> m) -> TermF prim loc v a -> m)
-> (forall m a. Monoid m => (a -> m) -> TermF prim loc v a -> m)
-> (forall a b. (a -> b -> b) -> b -> TermF prim loc v a -> b)
-> (forall a b. (a -> b -> b) -> b -> TermF prim loc v a -> b)
-> (forall b a. (b -> a -> b) -> b -> TermF prim loc v a -> b)
-> (forall b a. (b -> a -> b) -> b -> TermF prim loc v a -> b)
-> (forall a. (a -> a -> a) -> TermF prim loc v a -> a)
-> (forall a. (a -> a -> a) -> TermF prim loc v a -> a)
-> (forall a. TermF prim loc v a -> [a])
-> (forall a. TermF prim loc v a -> Bool)
-> (forall a. TermF prim loc v a -> Int)
-> (forall a. Eq a => a -> TermF prim loc v a -> Bool)
-> (forall a. Ord a => TermF prim loc v a -> a)
-> (forall a. Ord a => TermF prim loc v a -> a)
-> (forall a. Num a => TermF prim loc v a -> a)
-> (forall a. Num a => TermF prim loc v a -> a)
-> Foldable (TermF prim loc v)
forall a. Eq a => a -> TermF prim loc v a -> Bool
forall a. Num a => TermF prim loc v a -> a
forall a. Ord a => TermF prim loc v a -> a
forall m. Monoid m => TermF prim loc v m -> m
forall a. TermF prim loc v a -> Bool
forall a. TermF prim loc v a -> Int
forall a. TermF prim loc v a -> [a]
forall a. (a -> a -> a) -> TermF prim loc v a -> a
forall m a. Monoid m => (a -> m) -> TermF prim loc v a -> m
forall b a. (b -> a -> b) -> b -> TermF prim loc v a -> b
forall a b. (a -> b -> b) -> b -> TermF prim loc v a -> b
forall prim loc v a. Eq a => a -> TermF prim loc v a -> Bool
forall prim loc v a. Num a => TermF prim loc v a -> a
forall prim loc v a. Ord a => TermF prim loc v a -> a
forall prim loc v m. Monoid m => TermF prim loc v m -> m
forall prim loc v a. TermF prim loc v a -> Bool
forall prim loc v a. TermF prim loc v a -> Int
forall prim loc v a. TermF prim loc v a -> [a]
forall prim loc v a. (a -> a -> a) -> TermF prim loc v a -> a
forall prim loc v m a.
Monoid m =>
(a -> m) -> TermF prim loc v a -> m
forall prim loc v b a.
(b -> a -> b) -> b -> TermF prim loc v a -> b
forall prim loc v a b.
(a -> b -> b) -> b -> TermF prim 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 :: TermF prim loc v a -> a
$cproduct :: forall prim loc v a. Num a => TermF prim loc v a -> a
sum :: TermF prim loc v a -> a
$csum :: forall prim loc v a. Num a => TermF prim loc v a -> a
minimum :: TermF prim loc v a -> a
$cminimum :: forall prim loc v a. Ord a => TermF prim loc v a -> a
maximum :: TermF prim loc v a -> a
$cmaximum :: forall prim loc v a. Ord a => TermF prim loc v a -> a
elem :: a -> TermF prim loc v a -> Bool
$celem :: forall prim loc v a. Eq a => a -> TermF prim loc v a -> Bool
length :: TermF prim loc v a -> Int
$clength :: forall prim loc v a. TermF prim loc v a -> Int
null :: TermF prim loc v a -> Bool
$cnull :: forall prim loc v a. TermF prim loc v a -> Bool
toList :: TermF prim loc v a -> [a]
$ctoList :: forall prim loc v a. TermF prim loc v a -> [a]
foldl1 :: (a -> a -> a) -> TermF prim loc v a -> a
$cfoldl1 :: forall prim loc v a. (a -> a -> a) -> TermF prim loc v a -> a
foldr1 :: (a -> a -> a) -> TermF prim loc v a -> a
$cfoldr1 :: forall prim loc v a. (a -> a -> a) -> TermF prim loc v a -> a
foldl' :: (b -> a -> b) -> b -> TermF prim loc v a -> b
$cfoldl' :: forall prim loc v b a.
(b -> a -> b) -> b -> TermF prim loc v a -> b
foldl :: (b -> a -> b) -> b -> TermF prim loc v a -> b
$cfoldl :: forall prim loc v b a.
(b -> a -> b) -> b -> TermF prim loc v a -> b
foldr' :: (a -> b -> b) -> b -> TermF prim loc v a -> b
$cfoldr' :: forall prim loc v a b.
(a -> b -> b) -> b -> TermF prim loc v a -> b
foldr :: (a -> b -> b) -> b -> TermF prim loc v a -> b
$cfoldr :: forall prim loc v a b.
(a -> b -> b) -> b -> TermF prim loc v a -> b
foldMap' :: (a -> m) -> TermF prim loc v a -> m
$cfoldMap' :: forall prim loc v m a.
Monoid m =>
(a -> m) -> TermF prim loc v a -> m
foldMap :: (a -> m) -> TermF prim loc v a -> m
$cfoldMap :: forall prim loc v m a.
Monoid m =>
(a -> m) -> TermF prim loc v a -> m
fold :: TermF prim loc v m -> m
$cfold :: forall prim loc v m. Monoid m => TermF prim loc v m -> m
Foldable, Functor (TermF prim loc v)
Foldable (TermF prim loc v)
Functor (TermF prim loc v)
-> Foldable (TermF prim loc v)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TermF prim loc v a -> f (TermF prim loc v b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    TermF prim loc v (f a) -> f (TermF prim loc v a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TermF prim loc v a -> m (TermF prim loc v b))
-> (forall (m :: * -> *) a.
    Monad m =>
    TermF prim loc v (m a) -> m (TermF prim loc v a))
-> Traversable (TermF prim loc v)
(a -> f b) -> TermF prim loc v a -> f (TermF prim loc v b)
forall prim loc v. Functor (TermF prim loc v)
forall prim loc v. Foldable (TermF prim loc v)
forall prim loc v (m :: * -> *) a.
Monad m =>
TermF prim loc v (m a) -> m (TermF prim loc v a)
forall prim loc v (f :: * -> *) a.
Applicative f =>
TermF prim loc v (f a) -> f (TermF prim loc v a)
forall prim loc v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TermF prim loc v a -> m (TermF prim loc v b)
forall prim loc v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TermF prim loc v a -> f (TermF prim 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 =>
TermF prim loc v (m a) -> m (TermF prim loc v a)
forall (f :: * -> *) a.
Applicative f =>
TermF prim loc v (f a) -> f (TermF prim loc v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TermF prim loc v a -> m (TermF prim loc v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TermF prim loc v a -> f (TermF prim loc v b)
sequence :: TermF prim loc v (m a) -> m (TermF prim loc v a)
$csequence :: forall prim loc v (m :: * -> *) a.
Monad m =>
TermF prim loc v (m a) -> m (TermF prim loc v a)
mapM :: (a -> m b) -> TermF prim loc v a -> m (TermF prim loc v b)
$cmapM :: forall prim loc v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TermF prim loc v a -> m (TermF prim loc v b)
sequenceA :: TermF prim loc v (f a) -> f (TermF prim loc v a)
$csequenceA :: forall prim loc v (f :: * -> *) a.
Applicative f =>
TermF prim loc v (f a) -> f (TermF prim loc v a)
traverse :: (a -> f b) -> TermF prim loc v a -> f (TermF prim loc v b)
$ctraverse :: forall prim loc v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TermF prim loc v a -> f (TermF prim loc v b)
$cp2Traversable :: forall prim loc v. Foldable (TermF prim loc v)
$cp1Traversable :: forall prim loc v. Functor (TermF prim loc v)
Traversable, Typeable (TermF prim loc v r)
DataType
Constr
Typeable (TermF prim loc v r)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> TermF prim loc v r
    -> c (TermF prim loc v r))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TermF prim loc v r))
-> (TermF prim loc v r -> Constr)
-> (TermF prim loc v r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TermF prim loc v r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TermF prim loc v r)))
-> ((forall b. Data b => b -> b)
    -> TermF prim loc v r -> TermF prim loc v r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TermF prim loc v r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TermF prim loc v r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TermF prim loc v r -> m (TermF prim loc v r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TermF prim loc v r -> m (TermF prim loc v r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TermF prim loc v r -> m (TermF prim loc v r))
-> Data (TermF prim loc v r)
TermF prim loc v r -> DataType
TermF prim loc v r -> Constr
(forall b. Data b => b -> b)
-> TermF prim loc v r -> TermF prim loc v r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TermF prim loc v r
-> c (TermF prim loc v r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TermF prim loc v 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) -> TermF prim loc v r -> u
forall u. (forall d. Data d => d -> u) -> TermF prim loc v r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
Typeable (TermF prim loc v r)
forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
TermF prim loc v r -> DataType
forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
TermF prim loc v r -> Constr
forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
(forall b. Data b => b -> b)
-> TermF prim loc v r -> TermF prim loc v r
forall prim loc v r u.
(Data prim, Data loc, Data v, Data r) =>
Int -> (forall d. Data d => d -> u) -> TermF prim loc v r -> u
forall prim loc v r u.
(Data prim, Data loc, Data v, Data r) =>
(forall d. Data d => d -> u) -> TermF prim loc v r -> [u]
forall prim loc v r r r'.
(Data prim, Data loc, Data v, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
forall prim loc v r r r'.
(Data prim, Data loc, Data v, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
forall prim loc v r (m :: * -> *).
(Data prim, Data loc, Data v, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
forall prim loc v r (m :: * -> *).
(Data prim, Data loc, Data v, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
forall prim loc v r (c :: * -> *).
(Data prim, Data loc, Data v, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TermF prim loc v r)
forall prim loc v r (c :: * -> *).
(Data prim, Data loc, Data v, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TermF prim loc v r
-> c (TermF prim loc v r)
forall prim loc v r (t :: * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TermF prim loc v r))
forall prim loc v r (t :: * -> * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TermF prim loc v r))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TermF prim loc v r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TermF prim loc v r
-> c (TermF prim loc v r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TermF prim loc v r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TermF prim loc v r))
$cBottom :: Constr
$cConstr :: Constr
$cCase :: Constr
$cAssertType :: Constr
$cLetRec :: Constr
$cLet :: Constr
$cLam :: Constr
$cApp :: Constr
$cPrim :: Constr
$cVar :: Constr
$tTermF :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
$cgmapMo :: forall prim loc v r (m :: * -> *).
(Data prim, Data loc, Data v, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
gmapMp :: (forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
$cgmapMp :: forall prim loc v r (m :: * -> *).
(Data prim, Data loc, Data v, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
gmapM :: (forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
$cgmapM :: forall prim loc v r (m :: * -> *).
(Data prim, Data loc, Data v, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> TermF prim loc v r -> m (TermF prim loc v r)
gmapQi :: Int -> (forall d. Data d => d -> u) -> TermF prim loc v r -> u
$cgmapQi :: forall prim loc v r u.
(Data prim, Data loc, Data v, Data r) =>
Int -> (forall d. Data d => d -> u) -> TermF prim loc v r -> u
gmapQ :: (forall d. Data d => d -> u) -> TermF prim loc v r -> [u]
$cgmapQ :: forall prim loc v r u.
(Data prim, Data loc, Data v, Data r) =>
(forall d. Data d => d -> u) -> TermF prim loc v r -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
$cgmapQr :: forall prim loc v r r r'.
(Data prim, Data loc, Data v, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
$cgmapQl :: forall prim loc v r r r'.
(Data prim, Data loc, Data v, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TermF prim loc v r -> r
gmapT :: (forall b. Data b => b -> b)
-> TermF prim loc v r -> TermF prim loc v r
$cgmapT :: forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
(forall b. Data b => b -> b)
-> TermF prim loc v r -> TermF prim loc v r
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TermF prim loc v r))
$cdataCast2 :: forall prim loc v r (t :: * -> * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TermF prim loc v r))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (TermF prim loc v r))
$cdataCast1 :: forall prim loc v r (t :: * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TermF prim loc v r))
dataTypeOf :: TermF prim loc v r -> DataType
$cdataTypeOf :: forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
TermF prim loc v r -> DataType
toConstr :: TermF prim loc v r -> Constr
$ctoConstr :: forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
TermF prim loc v r -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TermF prim loc v r)
$cgunfold :: forall prim loc v r (c :: * -> *).
(Data prim, Data loc, Data v, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TermF prim loc v r)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TermF prim loc v r
-> c (TermF prim loc v r)
$cgfoldl :: forall prim loc v r (c :: * -> *).
(Data prim, Data loc, Data v, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TermF prim loc v r
-> c (TermF prim loc v r)
$cp1Data :: forall prim loc v r.
(Data prim, Data loc, Data v, Data r) =>
Typeable (TermF prim loc v r)
Data)

-- | Case alternatives
data CaseAlt loc v a = CaseAlt
  { CaseAlt loc v a -> loc
caseAlt'loc   :: loc
  -- ^ source code location
  , CaseAlt loc v a -> v
caseAlt'tag   :: v
  -- ^ tag of the constructor
  , CaseAlt loc v a -> [Typed loc v (loc, v)]
caseAlt'args  :: [Typed loc v (loc, v)]
  -- ^ arguments of the pattern matching
  , CaseAlt loc v a -> Type loc v
caseAlt'constrType :: Type loc v
  -- ^ type of the result expression, they should be the same for all cases
  , CaseAlt loc v a -> a
caseAlt'rhs   :: a
  -- ^ right-hand side of the case-alternative
  }
  deriving (Int -> CaseAlt loc v a -> ShowS
[CaseAlt loc v a] -> ShowS
CaseAlt loc v a -> String
(Int -> CaseAlt loc v a -> ShowS)
-> (CaseAlt loc v a -> String)
-> ([CaseAlt loc v a] -> ShowS)
-> Show (CaseAlt 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 -> CaseAlt loc v a -> ShowS
forall loc v a.
(Show loc, Show v, Show a) =>
[CaseAlt loc v a] -> ShowS
forall loc v a.
(Show loc, Show v, Show a) =>
CaseAlt loc v a -> String
showList :: [CaseAlt loc v a] -> ShowS
$cshowList :: forall loc v a.
(Show loc, Show v, Show a) =>
[CaseAlt loc v a] -> ShowS
show :: CaseAlt loc v a -> String
$cshow :: forall loc v a.
(Show loc, Show v, Show a) =>
CaseAlt loc v a -> String
showsPrec :: Int -> CaseAlt loc v a -> ShowS
$cshowsPrec :: forall loc v a.
(Show loc, Show v, Show a) =>
Int -> CaseAlt loc v a -> ShowS
Show, CaseAlt loc v a -> CaseAlt loc v a -> Bool
(CaseAlt loc v a -> CaseAlt loc v a -> Bool)
-> (CaseAlt loc v a -> CaseAlt loc v a -> Bool)
-> Eq (CaseAlt loc v a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc v a.
(Eq loc, Eq v, Eq a) =>
CaseAlt loc v a -> CaseAlt loc v a -> Bool
/= :: CaseAlt loc v a -> CaseAlt loc v a -> Bool
$c/= :: forall loc v a.
(Eq loc, Eq v, Eq a) =>
CaseAlt loc v a -> CaseAlt loc v a -> Bool
== :: CaseAlt loc v a -> CaseAlt loc v a -> Bool
$c== :: forall loc v a.
(Eq loc, Eq v, Eq a) =>
CaseAlt loc v a -> CaseAlt loc v a -> Bool
Eq, a -> CaseAlt loc v b -> CaseAlt loc v a
(a -> b) -> CaseAlt loc v a -> CaseAlt loc v b
(forall a b. (a -> b) -> CaseAlt loc v a -> CaseAlt loc v b)
-> (forall a b. a -> CaseAlt loc v b -> CaseAlt loc v a)
-> Functor (CaseAlt loc v)
forall a b. a -> CaseAlt loc v b -> CaseAlt loc v a
forall a b. (a -> b) -> CaseAlt loc v a -> CaseAlt loc v b
forall loc v a b. a -> CaseAlt loc v b -> CaseAlt loc v a
forall loc v a b. (a -> b) -> CaseAlt loc v a -> CaseAlt 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 -> CaseAlt loc v b -> CaseAlt loc v a
$c<$ :: forall loc v a b. a -> CaseAlt loc v b -> CaseAlt loc v a
fmap :: (a -> b) -> CaseAlt loc v a -> CaseAlt loc v b
$cfmap :: forall loc v a b. (a -> b) -> CaseAlt loc v a -> CaseAlt loc v b
Functor, CaseAlt loc v a -> Bool
(a -> m) -> CaseAlt loc v a -> m
(a -> b -> b) -> b -> CaseAlt loc v a -> b
(forall m. Monoid m => CaseAlt loc v m -> m)
-> (forall m a. Monoid m => (a -> m) -> CaseAlt loc v a -> m)
-> (forall m a. Monoid m => (a -> m) -> CaseAlt loc v a -> m)
-> (forall a b. (a -> b -> b) -> b -> CaseAlt loc v a -> b)
-> (forall a b. (a -> b -> b) -> b -> CaseAlt loc v a -> b)
-> (forall b a. (b -> a -> b) -> b -> CaseAlt loc v a -> b)
-> (forall b a. (b -> a -> b) -> b -> CaseAlt loc v a -> b)
-> (forall a. (a -> a -> a) -> CaseAlt loc v a -> a)
-> (forall a. (a -> a -> a) -> CaseAlt loc v a -> a)
-> (forall a. CaseAlt loc v a -> [a])
-> (forall a. CaseAlt loc v a -> Bool)
-> (forall a. CaseAlt loc v a -> Int)
-> (forall a. Eq a => a -> CaseAlt loc v a -> Bool)
-> (forall a. Ord a => CaseAlt loc v a -> a)
-> (forall a. Ord a => CaseAlt loc v a -> a)
-> (forall a. Num a => CaseAlt loc v a -> a)
-> (forall a. Num a => CaseAlt loc v a -> a)
-> Foldable (CaseAlt loc v)
forall a. Eq a => a -> CaseAlt loc v a -> Bool
forall a. Num a => CaseAlt loc v a -> a
forall a. Ord a => CaseAlt loc v a -> a
forall m. Monoid m => CaseAlt loc v m -> m
forall a. CaseAlt loc v a -> Bool
forall a. CaseAlt loc v a -> Int
forall a. CaseAlt loc v a -> [a]
forall a. (a -> a -> a) -> CaseAlt loc v a -> a
forall m a. Monoid m => (a -> m) -> CaseAlt loc v a -> m
forall b a. (b -> a -> b) -> b -> CaseAlt loc v a -> b
forall a b. (a -> b -> b) -> b -> CaseAlt loc v a -> b
forall loc v a. Eq a => a -> CaseAlt loc v a -> Bool
forall loc v a. Num a => CaseAlt loc v a -> a
forall loc v a. Ord a => CaseAlt loc v a -> a
forall loc v m. Monoid m => CaseAlt loc v m -> m
forall loc v a. CaseAlt loc v a -> Bool
forall loc v a. CaseAlt loc v a -> Int
forall loc v a. CaseAlt loc v a -> [a]
forall loc v a. (a -> a -> a) -> CaseAlt loc v a -> a
forall loc v m a. Monoid m => (a -> m) -> CaseAlt loc v a -> m
forall loc v b a. (b -> a -> b) -> b -> CaseAlt loc v a -> b
forall loc v a b. (a -> b -> b) -> b -> CaseAlt 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 :: CaseAlt loc v a -> a
$cproduct :: forall loc v a. Num a => CaseAlt loc v a -> a
sum :: CaseAlt loc v a -> a
$csum :: forall loc v a. Num a => CaseAlt loc v a -> a
minimum :: CaseAlt loc v a -> a
$cminimum :: forall loc v a. Ord a => CaseAlt loc v a -> a
maximum :: CaseAlt loc v a -> a
$cmaximum :: forall loc v a. Ord a => CaseAlt loc v a -> a
elem :: a -> CaseAlt loc v a -> Bool
$celem :: forall loc v a. Eq a => a -> CaseAlt loc v a -> Bool
length :: CaseAlt loc v a -> Int
$clength :: forall loc v a. CaseAlt loc v a -> Int
null :: CaseAlt loc v a -> Bool
$cnull :: forall loc v a. CaseAlt loc v a -> Bool
toList :: CaseAlt loc v a -> [a]
$ctoList :: forall loc v a. CaseAlt loc v a -> [a]
foldl1 :: (a -> a -> a) -> CaseAlt loc v a -> a
$cfoldl1 :: forall loc v a. (a -> a -> a) -> CaseAlt loc v a -> a
foldr1 :: (a -> a -> a) -> CaseAlt loc v a -> a
$cfoldr1 :: forall loc v a. (a -> a -> a) -> CaseAlt loc v a -> a
foldl' :: (b -> a -> b) -> b -> CaseAlt loc v a -> b
$cfoldl' :: forall loc v b a. (b -> a -> b) -> b -> CaseAlt loc v a -> b
foldl :: (b -> a -> b) -> b -> CaseAlt loc v a -> b
$cfoldl :: forall loc v b a. (b -> a -> b) -> b -> CaseAlt loc v a -> b
foldr' :: (a -> b -> b) -> b -> CaseAlt loc v a -> b
$cfoldr' :: forall loc v a b. (a -> b -> b) -> b -> CaseAlt loc v a -> b
foldr :: (a -> b -> b) -> b -> CaseAlt loc v a -> b
$cfoldr :: forall loc v a b. (a -> b -> b) -> b -> CaseAlt loc v a -> b
foldMap' :: (a -> m) -> CaseAlt loc v a -> m
$cfoldMap' :: forall loc v m a. Monoid m => (a -> m) -> CaseAlt loc v a -> m
foldMap :: (a -> m) -> CaseAlt loc v a -> m
$cfoldMap :: forall loc v m a. Monoid m => (a -> m) -> CaseAlt loc v a -> m
fold :: CaseAlt loc v m -> m
$cfold :: forall loc v m. Monoid m => CaseAlt loc v m -> m
Foldable, Functor (CaseAlt loc v)
Foldable (CaseAlt loc v)
Functor (CaseAlt loc v)
-> Foldable (CaseAlt loc v)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CaseAlt loc v a -> f (CaseAlt loc v b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    CaseAlt loc v (f a) -> f (CaseAlt loc v a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CaseAlt loc v a -> m (CaseAlt loc v b))
-> (forall (m :: * -> *) a.
    Monad m =>
    CaseAlt loc v (m a) -> m (CaseAlt loc v a))
-> Traversable (CaseAlt loc v)
(a -> f b) -> CaseAlt loc v a -> f (CaseAlt loc v b)
forall loc v. Functor (CaseAlt loc v)
forall loc v. Foldable (CaseAlt loc v)
forall loc v (m :: * -> *) a.
Monad m =>
CaseAlt loc v (m a) -> m (CaseAlt loc v a)
forall loc v (f :: * -> *) a.
Applicative f =>
CaseAlt loc v (f a) -> f (CaseAlt loc v a)
forall loc v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseAlt loc v a -> m (CaseAlt loc v b)
forall loc v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseAlt loc v a -> f (CaseAlt 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 =>
CaseAlt loc v (m a) -> m (CaseAlt loc v a)
forall (f :: * -> *) a.
Applicative f =>
CaseAlt loc v (f a) -> f (CaseAlt loc v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseAlt loc v a -> m (CaseAlt loc v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseAlt loc v a -> f (CaseAlt loc v b)
sequence :: CaseAlt loc v (m a) -> m (CaseAlt loc v a)
$csequence :: forall loc v (m :: * -> *) a.
Monad m =>
CaseAlt loc v (m a) -> m (CaseAlt loc v a)
mapM :: (a -> m b) -> CaseAlt loc v a -> m (CaseAlt loc v b)
$cmapM :: forall loc v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseAlt loc v a -> m (CaseAlt loc v b)
sequenceA :: CaseAlt loc v (f a) -> f (CaseAlt loc v a)
$csequenceA :: forall loc v (f :: * -> *) a.
Applicative f =>
CaseAlt loc v (f a) -> f (CaseAlt loc v a)
traverse :: (a -> f b) -> CaseAlt loc v a -> f (CaseAlt loc v b)
$ctraverse :: forall loc v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseAlt loc v a -> f (CaseAlt loc v b)
$cp2Traversable :: forall loc v. Foldable (CaseAlt loc v)
$cp1Traversable :: forall loc v. Functor (CaseAlt loc v)
Traversable, Typeable (CaseAlt loc v a)
DataType
Constr
Typeable (CaseAlt loc v a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CaseAlt loc v a -> c (CaseAlt loc v a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CaseAlt loc v a))
-> (CaseAlt loc v a -> Constr)
-> (CaseAlt loc v a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CaseAlt loc v a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CaseAlt loc v a)))
-> ((forall b. Data b => b -> b)
    -> CaseAlt loc v a -> CaseAlt loc v a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseAlt loc v a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseAlt loc v a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CaseAlt loc v a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CaseAlt loc v a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CaseAlt loc v a -> m (CaseAlt loc v a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CaseAlt loc v a -> m (CaseAlt loc v a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CaseAlt loc v a -> m (CaseAlt loc v a))
-> Data (CaseAlt loc v a)
CaseAlt loc v a -> DataType
CaseAlt loc v a -> Constr
(forall b. Data b => b -> b) -> CaseAlt loc v a -> CaseAlt loc v a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseAlt loc v a -> c (CaseAlt loc v a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseAlt 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) -> CaseAlt loc v a -> u
forall u. (forall d. Data d => d -> u) -> CaseAlt loc v a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt loc v a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt loc v a -> r
forall loc v a.
(Data loc, Data v, Data a) =>
Typeable (CaseAlt loc v a)
forall loc v a.
(Data loc, Data v, Data a) =>
CaseAlt loc v a -> DataType
forall loc v a.
(Data loc, Data v, Data a) =>
CaseAlt loc v a -> Constr
forall loc v a.
(Data loc, Data v, Data a) =>
(forall b. Data b => b -> b) -> CaseAlt loc v a -> CaseAlt loc v a
forall loc v a u.
(Data loc, Data v, Data a) =>
Int -> (forall d. Data d => d -> u) -> CaseAlt loc v a -> u
forall loc v a u.
(Data loc, Data v, Data a) =>
(forall d. Data d => d -> u) -> CaseAlt 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') -> CaseAlt 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') -> CaseAlt loc v a -> r
forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt 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 (CaseAlt 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) -> CaseAlt loc v a -> c (CaseAlt 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 (CaseAlt 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 (CaseAlt loc v a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseAlt loc v a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseAlt loc v a -> c (CaseAlt loc v a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CaseAlt loc v a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CaseAlt loc v a))
$cCaseAlt :: Constr
$tCaseAlt :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
$cgmapMo :: forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
gmapMp :: (forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
$cgmapMp :: forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
gmapM :: (forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
$cgmapM :: forall loc v a (m :: * -> *).
(Data loc, Data v, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CaseAlt loc v a -> m (CaseAlt loc v a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> CaseAlt loc v a -> u
$cgmapQi :: forall loc v a u.
(Data loc, Data v, Data a) =>
Int -> (forall d. Data d => d -> u) -> CaseAlt loc v a -> u
gmapQ :: (forall d. Data d => d -> u) -> CaseAlt loc v a -> [u]
$cgmapQ :: forall loc v a u.
(Data loc, Data v, Data a) =>
(forall d. Data d => d -> u) -> CaseAlt loc v a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt 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') -> CaseAlt loc v a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseAlt 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') -> CaseAlt loc v a -> r
gmapT :: (forall b. Data b => b -> b) -> CaseAlt loc v a -> CaseAlt loc v a
$cgmapT :: forall loc v a.
(Data loc, Data v, Data a) =>
(forall b. Data b => b -> b) -> CaseAlt loc v a -> CaseAlt loc v a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CaseAlt 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 (CaseAlt loc v a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (CaseAlt 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 (CaseAlt loc v a))
dataTypeOf :: CaseAlt loc v a -> DataType
$cdataTypeOf :: forall loc v a.
(Data loc, Data v, Data a) =>
CaseAlt loc v a -> DataType
toConstr :: CaseAlt loc v a -> Constr
$ctoConstr :: forall loc v a.
(Data loc, Data v, Data a) =>
CaseAlt loc v a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CaseAlt 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 (CaseAlt loc v a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseAlt loc v a -> c (CaseAlt 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) -> CaseAlt loc v a -> c (CaseAlt loc v a)
$cp1Data :: forall loc v a.
(Data loc, Data v, Data a) =>
Typeable (CaseAlt loc v a)
Data)

-- | Local variable definition.
--
-- > let lhs = rhs in ...
data Bind loc var r = Bind
  { Bind loc var r -> loc
bind'loc :: loc             -- ^ Source code location
  , Bind loc var r -> var
bind'lhs :: var             -- ^ Variable name
  , Bind loc var r -> r
bind'rhs :: r               -- ^ Definition (right-hand side)
  } deriving (Int -> Bind loc var r -> ShowS
[Bind loc var r] -> ShowS
Bind loc var r -> String
(Int -> Bind loc var r -> ShowS)
-> (Bind loc var r -> String)
-> ([Bind loc var r] -> ShowS)
-> Show (Bind 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 -> Bind loc var r -> ShowS
forall loc var r.
(Show loc, Show var, Show r) =>
[Bind loc var r] -> ShowS
forall loc var r.
(Show loc, Show var, Show r) =>
Bind loc var r -> String
showList :: [Bind loc var r] -> ShowS
$cshowList :: forall loc var r.
(Show loc, Show var, Show r) =>
[Bind loc var r] -> ShowS
show :: Bind loc var r -> String
$cshow :: forall loc var r.
(Show loc, Show var, Show r) =>
Bind loc var r -> String
showsPrec :: Int -> Bind loc var r -> ShowS
$cshowsPrec :: forall loc var r.
(Show loc, Show var, Show r) =>
Int -> Bind loc var r -> ShowS
Show, Bind loc var r -> Bind loc var r -> Bool
(Bind loc var r -> Bind loc var r -> Bool)
-> (Bind loc var r -> Bind loc var r -> Bool)
-> Eq (Bind loc var r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall loc var r.
(Eq loc, Eq var, Eq r) =>
Bind loc var r -> Bind loc var r -> Bool
/= :: Bind loc var r -> Bind loc var r -> Bool
$c/= :: forall loc var r.
(Eq loc, Eq var, Eq r) =>
Bind loc var r -> Bind loc var r -> Bool
== :: Bind loc var r -> Bind loc var r -> Bool
$c== :: forall loc var r.
(Eq loc, Eq var, Eq r) =>
Bind loc var r -> Bind loc var r -> Bool
Eq, a -> Bind loc var b -> Bind loc var a
(a -> b) -> Bind loc var a -> Bind loc var b
(forall a b. (a -> b) -> Bind loc var a -> Bind loc var b)
-> (forall a b. a -> Bind loc var b -> Bind loc var a)
-> Functor (Bind loc var)
forall a b. a -> Bind loc var b -> Bind loc var a
forall a b. (a -> b) -> Bind loc var a -> Bind loc var b
forall loc var a b. a -> Bind loc var b -> Bind loc var a
forall loc var a b. (a -> b) -> Bind loc var a -> Bind 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 -> Bind loc var b -> Bind loc var a
$c<$ :: forall loc var a b. a -> Bind loc var b -> Bind loc var a
fmap :: (a -> b) -> Bind loc var a -> Bind loc var b
$cfmap :: forall loc var a b. (a -> b) -> Bind loc var a -> Bind loc var b
Functor, Bind loc var a -> Bool
(a -> m) -> Bind loc var a -> m
(a -> b -> b) -> b -> Bind loc var a -> b
(forall m. Monoid m => Bind loc var m -> m)
-> (forall m a. Monoid m => (a -> m) -> Bind loc var a -> m)
-> (forall m a. Monoid m => (a -> m) -> Bind loc var a -> m)
-> (forall a b. (a -> b -> b) -> b -> Bind loc var a -> b)
-> (forall a b. (a -> b -> b) -> b -> Bind loc var a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bind loc var a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bind loc var a -> b)
-> (forall a. (a -> a -> a) -> Bind loc var a -> a)
-> (forall a. (a -> a -> a) -> Bind loc var a -> a)
-> (forall a. Bind loc var a -> [a])
-> (forall a. Bind loc var a -> Bool)
-> (forall a. Bind loc var a -> Int)
-> (forall a. Eq a => a -> Bind loc var a -> Bool)
-> (forall a. Ord a => Bind loc var a -> a)
-> (forall a. Ord a => Bind loc var a -> a)
-> (forall a. Num a => Bind loc var a -> a)
-> (forall a. Num a => Bind loc var a -> a)
-> Foldable (Bind loc var)
forall a. Eq a => a -> Bind loc var a -> Bool
forall a. Num a => Bind loc var a -> a
forall a. Ord a => Bind loc var a -> a
forall m. Monoid m => Bind loc var m -> m
forall a. Bind loc var a -> Bool
forall a. Bind loc var a -> Int
forall a. Bind loc var a -> [a]
forall a. (a -> a -> a) -> Bind loc var a -> a
forall m a. Monoid m => (a -> m) -> Bind loc var a -> m
forall b a. (b -> a -> b) -> b -> Bind loc var a -> b
forall a b. (a -> b -> b) -> b -> Bind loc var a -> b
forall loc var a. Eq a => a -> Bind loc var a -> Bool
forall loc var a. Num a => Bind loc var a -> a
forall loc var a. Ord a => Bind loc var a -> a
forall loc var m. Monoid m => Bind loc var m -> m
forall loc var a. Bind loc var a -> Bool
forall loc var a. Bind loc var a -> Int
forall loc var a. Bind loc var a -> [a]
forall loc var a. (a -> a -> a) -> Bind loc var a -> a
forall loc var m a. Monoid m => (a -> m) -> Bind loc var a -> m
forall loc var b a. (b -> a -> b) -> b -> Bind loc var a -> b
forall loc var a b. (a -> b -> b) -> b -> Bind 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 :: Bind loc var a -> a
$cproduct :: forall loc var a. Num a => Bind loc var a -> a
sum :: Bind loc var a -> a
$csum :: forall loc var a. Num a => Bind loc var a -> a
minimum :: Bind loc var a -> a
$cminimum :: forall loc var a. Ord a => Bind loc var a -> a
maximum :: Bind loc var a -> a
$cmaximum :: forall loc var a. Ord a => Bind loc var a -> a
elem :: a -> Bind loc var a -> Bool
$celem :: forall loc var a. Eq a => a -> Bind loc var a -> Bool
length :: Bind loc var a -> Int
$clength :: forall loc var a. Bind loc var a -> Int
null :: Bind loc var a -> Bool
$cnull :: forall loc var a. Bind loc var a -> Bool
toList :: Bind loc var a -> [a]
$ctoList :: forall loc var a. Bind loc var a -> [a]
foldl1 :: (a -> a -> a) -> Bind loc var a -> a
$cfoldl1 :: forall loc var a. (a -> a -> a) -> Bind loc var a -> a
foldr1 :: (a -> a -> a) -> Bind loc var a -> a
$cfoldr1 :: forall loc var a. (a -> a -> a) -> Bind loc var a -> a
foldl' :: (b -> a -> b) -> b -> Bind loc var a -> b
$cfoldl' :: forall loc var b a. (b -> a -> b) -> b -> Bind loc var a -> b
foldl :: (b -> a -> b) -> b -> Bind loc var a -> b
$cfoldl :: forall loc var b a. (b -> a -> b) -> b -> Bind loc var a -> b
foldr' :: (a -> b -> b) -> b -> Bind loc var a -> b
$cfoldr' :: forall loc var a b. (a -> b -> b) -> b -> Bind loc var a -> b
foldr :: (a -> b -> b) -> b -> Bind loc var a -> b
$cfoldr :: forall loc var a b. (a -> b -> b) -> b -> Bind loc var a -> b
foldMap' :: (a -> m) -> Bind loc var a -> m
$cfoldMap' :: forall loc var m a. Monoid m => (a -> m) -> Bind loc var a -> m
foldMap :: (a -> m) -> Bind loc var a -> m
$cfoldMap :: forall loc var m a. Monoid m => (a -> m) -> Bind loc var a -> m
fold :: Bind loc var m -> m
$cfold :: forall loc var m. Monoid m => Bind loc var m -> m
Foldable, Functor (Bind loc var)
Foldable (Bind loc var)
Functor (Bind loc var)
-> Foldable (Bind loc var)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bind loc var a -> f (Bind loc var b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Bind loc var (f a) -> f (Bind loc var a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bind loc var a -> m (Bind loc var b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Bind loc var (m a) -> m (Bind loc var a))
-> Traversable (Bind loc var)
(a -> f b) -> Bind loc var a -> f (Bind loc var b)
forall loc var. Functor (Bind loc var)
forall loc var. Foldable (Bind loc var)
forall loc var (m :: * -> *) a.
Monad m =>
Bind loc var (m a) -> m (Bind loc var a)
forall loc var (f :: * -> *) a.
Applicative f =>
Bind loc var (f a) -> f (Bind loc var a)
forall loc var (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bind loc var a -> m (Bind loc var b)
forall loc var (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bind loc var a -> f (Bind 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 =>
Bind loc var (m a) -> m (Bind loc var a)
forall (f :: * -> *) a.
Applicative f =>
Bind loc var (f a) -> f (Bind loc var a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bind loc var a -> m (Bind loc var b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bind loc var a -> f (Bind loc var b)
sequence :: Bind loc var (m a) -> m (Bind loc var a)
$csequence :: forall loc var (m :: * -> *) a.
Monad m =>
Bind loc var (m a) -> m (Bind loc var a)
mapM :: (a -> m b) -> Bind loc var a -> m (Bind loc var b)
$cmapM :: forall loc var (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bind loc var a -> m (Bind loc var b)
sequenceA :: Bind loc var (f a) -> f (Bind loc var a)
$csequenceA :: forall loc var (f :: * -> *) a.
Applicative f =>
Bind loc var (f a) -> f (Bind loc var a)
traverse :: (a -> f b) -> Bind loc var a -> f (Bind loc var b)
$ctraverse :: forall loc var (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bind loc var a -> f (Bind loc var b)
$cp2Traversable :: forall loc var. Foldable (Bind loc var)
$cp1Traversable :: forall loc var. Functor (Bind loc var)
Traversable, Typeable (Bind loc var r)
DataType
Constr
Typeable (Bind loc var r)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bind loc var r -> c (Bind loc var r))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bind loc var r))
-> (Bind loc var r -> Constr)
-> (Bind loc var r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bind loc var r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bind loc var r)))
-> ((forall b. Data b => b -> b)
    -> Bind loc var r -> Bind loc var r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bind loc var r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bind loc var r -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Bind loc var r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Bind loc var r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Bind loc var r -> m (Bind loc var r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Bind loc var r -> m (Bind loc var r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Bind loc var r -> m (Bind loc var r))
-> Data (Bind loc var r)
Bind loc var r -> DataType
Bind loc var r -> Constr
(forall b. Data b => b -> b) -> Bind loc var r -> Bind loc var r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bind loc var r -> c (Bind loc var r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bind 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) -> Bind loc var r -> u
forall u. (forall d. Data d => d -> u) -> Bind loc var r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bind loc var r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bind loc var r -> r
forall loc var r.
(Data loc, Data var, Data r) =>
Typeable (Bind loc var r)
forall loc var r.
(Data loc, Data var, Data r) =>
Bind loc var r -> DataType
forall loc var r.
(Data loc, Data var, Data r) =>
Bind loc var r -> Constr
forall loc var r.
(Data loc, Data var, Data r) =>
(forall b. Data b => b -> b) -> Bind loc var r -> Bind loc var r
forall loc var r u.
(Data loc, Data var, Data r) =>
Int -> (forall d. Data d => d -> u) -> Bind loc var r -> u
forall loc var r u.
(Data loc, Data var, Data r) =>
(forall d. Data d => d -> u) -> Bind 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') -> Bind 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') -> Bind loc var r -> r
forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind 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 (Bind 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) -> Bind loc var r -> c (Bind 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 (Bind 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 (Bind loc var r))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bind loc var r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bind loc var r -> c (Bind loc var r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Bind loc var r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bind loc var r))
$cBind :: Constr
$tBind :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
$cgmapMo :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
gmapMp :: (forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
$cgmapMp :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
gmapM :: (forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
$cgmapM :: forall loc var r (m :: * -> *).
(Data loc, Data var, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> Bind loc var r -> m (Bind loc var r)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Bind loc var r -> u
$cgmapQi :: forall loc var r u.
(Data loc, Data var, Data r) =>
Int -> (forall d. Data d => d -> u) -> Bind loc var r -> u
gmapQ :: (forall d. Data d => d -> u) -> Bind loc var r -> [u]
$cgmapQ :: forall loc var r u.
(Data loc, Data var, Data r) =>
(forall d. Data d => d -> u) -> Bind loc var r -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bind 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') -> Bind loc var r -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bind 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') -> Bind loc var r -> r
gmapT :: (forall b. Data b => b -> b) -> Bind loc var r -> Bind loc var r
$cgmapT :: forall loc var r.
(Data loc, Data var, Data r) =>
(forall b. Data b => b -> b) -> Bind loc var r -> Bind loc var r
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Bind 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 (Bind loc var r))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Bind 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 (Bind loc var r))
dataTypeOf :: Bind loc var r -> DataType
$cdataTypeOf :: forall loc var r.
(Data loc, Data var, Data r) =>
Bind loc var r -> DataType
toConstr :: Bind loc var r -> Constr
$ctoConstr :: forall loc var r.
(Data loc, Data var, Data r) =>
Bind loc var r -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Bind 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 (Bind loc var r)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bind loc var r -> c (Bind 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) -> Bind loc var r -> c (Bind loc var r)
$cp1Data :: forall loc var r.
(Data loc, Data var, Data r) =>
Typeable (Bind loc var r)
Data)

$(deriveShow1 ''TermF)
$(deriveEq1   ''TermF)
$(deriveOrd1  ''TermF)
$(deriveShow1 ''Bind)
$(deriveEq1   ''Bind)
$(deriveOrd1  ''Bind)
$(deriveShow1 ''CaseAlt)
$(deriveEq1   ''CaseAlt)
$(deriveOrd1  ''CaseAlt)

-- | The type of terms.
newtype Term prim loc v = Term { Term prim loc v -> Fix (TermF prim loc v)
unTerm :: Fix (TermF prim loc v) }
  deriving (Int -> Term prim loc v -> ShowS
[Term prim loc v] -> ShowS
Term prim loc v -> String
(Int -> Term prim loc v -> ShowS)
-> (Term prim loc v -> String)
-> ([Term prim loc v] -> ShowS)
-> Show (Term prim loc v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall prim loc v.
(Show prim, Show loc, Show v) =>
Int -> Term prim loc v -> ShowS
forall prim loc v.
(Show prim, Show loc, Show v) =>
[Term prim loc v] -> ShowS
forall prim loc v.
(Show prim, Show loc, Show v) =>
Term prim loc v -> String
showList :: [Term prim loc v] -> ShowS
$cshowList :: forall prim loc v.
(Show prim, Show loc, Show v) =>
[Term prim loc v] -> ShowS
show :: Term prim loc v -> String
$cshow :: forall prim loc v.
(Show prim, Show loc, Show v) =>
Term prim loc v -> String
showsPrec :: Int -> Term prim loc v -> ShowS
$cshowsPrec :: forall prim loc v.
(Show prim, Show loc, Show v) =>
Int -> Term prim loc v -> ShowS
Show, Term prim loc v -> Term prim loc v -> Bool
(Term prim loc v -> Term prim loc v -> Bool)
-> (Term prim loc v -> Term prim loc v -> Bool)
-> Eq (Term prim loc v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall prim loc v.
(Eq prim, Eq loc, Eq v) =>
Term prim loc v -> Term prim loc v -> Bool
/= :: Term prim loc v -> Term prim loc v -> Bool
$c/= :: forall prim loc v.
(Eq prim, Eq loc, Eq v) =>
Term prim loc v -> Term prim loc v -> Bool
== :: Term prim loc v -> Term prim loc v -> Bool
$c== :: forall prim loc v.
(Eq prim, Eq loc, Eq v) =>
Term prim loc v -> Term prim loc v -> Bool
Eq, Typeable (Term prim loc v)
DataType
Constr
Typeable (Term prim loc v)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Term prim loc v -> c (Term prim loc v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Term prim loc v))
-> (Term prim loc v -> Constr)
-> (Term prim loc v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Term prim loc v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Term prim loc v)))
-> ((forall b. Data b => b -> b)
    -> Term prim loc v -> Term prim loc v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Term prim loc v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Term prim loc v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Term prim loc v -> m (Term prim loc v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Term prim loc v -> m (Term prim loc v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Term prim loc v -> m (Term prim loc v))
-> Data (Term prim loc v)
Term prim loc v -> DataType
Term prim loc v -> Constr
(forall b. Data b => b -> b) -> Term prim loc v -> Term prim loc v
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term prim loc v -> c (Term prim loc v)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term prim loc v)
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) -> Term prim loc v -> u
forall u. (forall d. Data d => d -> u) -> Term prim loc v -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
forall prim loc v.
(Data prim, Data loc, Data v) =>
Typeable (Term prim loc v)
forall prim loc v.
(Data prim, Data loc, Data v) =>
Term prim loc v -> DataType
forall prim loc v.
(Data prim, Data loc, Data v) =>
Term prim loc v -> Constr
forall prim loc v.
(Data prim, Data loc, Data v) =>
(forall b. Data b => b -> b) -> Term prim loc v -> Term prim loc v
forall prim loc v u.
(Data prim, Data loc, Data v) =>
Int -> (forall d. Data d => d -> u) -> Term prim loc v -> u
forall prim loc v u.
(Data prim, Data loc, Data v) =>
(forall d. Data d => d -> u) -> Term prim loc v -> [u]
forall prim loc v r r'.
(Data prim, Data loc, Data v) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
forall prim loc v r r'.
(Data prim, Data loc, Data v) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
forall prim loc v (m :: * -> *).
(Data prim, Data loc, Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
forall prim loc v (m :: * -> *).
(Data prim, Data loc, Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
forall prim loc v (c :: * -> *).
(Data prim, Data loc, Data v) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term prim loc v)
forall prim loc v (c :: * -> *).
(Data prim, Data loc, Data v) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term prim loc v -> c (Term prim loc v)
forall prim loc v (t :: * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Term prim loc v))
forall prim loc v (t :: * -> * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Term prim loc v))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term prim loc v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term prim loc v -> c (Term prim loc v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Term prim loc v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Term prim loc v))
$cTerm :: Constr
$tTerm :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
$cgmapMo :: forall prim loc v (m :: * -> *).
(Data prim, Data loc, Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
gmapMp :: (forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
$cgmapMp :: forall prim loc v (m :: * -> *).
(Data prim, Data loc, Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
gmapM :: (forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
$cgmapM :: forall prim loc v (m :: * -> *).
(Data prim, Data loc, Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> Term prim loc v -> m (Term prim loc v)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Term prim loc v -> u
$cgmapQi :: forall prim loc v u.
(Data prim, Data loc, Data v) =>
Int -> (forall d. Data d => d -> u) -> Term prim loc v -> u
gmapQ :: (forall d. Data d => d -> u) -> Term prim loc v -> [u]
$cgmapQ :: forall prim loc v u.
(Data prim, Data loc, Data v) =>
(forall d. Data d => d -> u) -> Term prim loc v -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
$cgmapQr :: forall prim loc v r r'.
(Data prim, Data loc, Data v) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
$cgmapQl :: forall prim loc v r r'.
(Data prim, Data loc, Data v) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term prim loc v -> r
gmapT :: (forall b. Data b => b -> b) -> Term prim loc v -> Term prim loc v
$cgmapT :: forall prim loc v.
(Data prim, Data loc, Data v) =>
(forall b. Data b => b -> b) -> Term prim loc v -> Term prim loc v
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Term prim loc v))
$cdataCast2 :: forall prim loc v (t :: * -> * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Term prim loc v))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Term prim loc v))
$cdataCast1 :: forall prim loc v (t :: * -> *) (c :: * -> *).
(Data prim, Data loc, Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Term prim loc v))
dataTypeOf :: Term prim loc v -> DataType
$cdataTypeOf :: forall prim loc v.
(Data prim, Data loc, Data v) =>
Term prim loc v -> DataType
toConstr :: Term prim loc v -> Constr
$ctoConstr :: forall prim loc v.
(Data prim, Data loc, Data v) =>
Term prim loc v -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term prim loc v)
$cgunfold :: forall prim loc v (c :: * -> *).
(Data prim, Data loc, Data v) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term prim loc v)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term prim loc v -> c (Term prim loc v)
$cgfoldl :: forall prim loc v (c :: * -> *).
(Data prim, Data loc, Data v) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term prim loc v -> c (Term prim loc v)
$cp1Data :: forall prim loc v.
(Data prim, Data loc, Data v) =>
Typeable (Term prim loc v)
Data)

instance Functor (Term prim loc) where
  fmap :: (a -> b) -> Term prim loc a -> Term prim loc b
fmap a -> b
f (Term Fix (TermF prim loc a)
x) =  Fix (TermF prim loc b) -> Term prim loc b
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc b) -> Term prim loc b)
-> Fix (TermF prim loc b) -> Term prim loc b
forall a b. (a -> b) -> a -> b
$ (TermF prim loc a (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> Fix (TermF prim loc a) -> Fix (TermF prim loc b)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TermF prim loc a (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
go Fix (TermF prim loc a)
x
    where
      go :: TermF prim loc a (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
go = \case
        Var loc
loc a
v    -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc -> b -> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> v -> TermF prim loc v r
Var loc
loc (a -> b
f a
v)
        Prim loc
loc prim
p   -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc -> prim -> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> prim -> TermF prim loc v r
Prim loc
loc prim
p
        App loc
loc Fix (TermF prim loc b)
a Fix (TermF prim loc b)
b  -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc b)
-> Fix (TermF prim loc b)
-> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> r -> r -> TermF prim loc v r
App loc
loc Fix (TermF prim loc b)
a Fix (TermF prim loc b)
b
        Lam loc
loc a
v Fix (TermF prim loc b)
a  -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> b
-> Fix (TermF prim loc b)
-> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> v -> r -> TermF prim loc v r
Lam loc
loc (a -> b
f a
v) Fix (TermF prim loc b)
a
        Let loc
loc Bind loc a (Fix (TermF prim loc b))
v Fix (TermF prim loc b)
a  -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> Bind loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
-> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> Bind loc v r -> r -> TermF prim loc v r
Let loc
loc (Bind loc a (Fix (TermF prim loc b))
v { bind'lhs :: b
bind'lhs = a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Bind loc a (Fix (TermF prim loc b)) -> a
forall loc var r. Bind loc var r -> var
bind'lhs Bind loc a (Fix (TermF prim loc b))
v }) Fix (TermF prim loc b)
a
        LetRec loc
loc [Bind loc a (Fix (TermF prim loc b))]
vs Fix (TermF prim loc b)
a -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> [Bind loc b (Fix (TermF prim loc b))]
-> Fix (TermF prim loc b)
-> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r.
loc -> [Bind loc v r] -> r -> TermF prim loc v r
LetRec loc
loc ((Bind loc a (Fix (TermF prim loc b))
 -> Bind loc b (Fix (TermF prim loc b)))
-> [Bind loc a (Fix (TermF prim loc b))]
-> [Bind loc b (Fix (TermF prim loc b))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Bind loc a (Fix (TermF prim loc b))
b ->  Bind loc a (Fix (TermF prim loc b))
b { bind'lhs :: b
bind'lhs = a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Bind loc a (Fix (TermF prim loc b)) -> a
forall loc var r. Bind loc var r -> var
bind'lhs Bind loc a (Fix (TermF prim loc b))
b }) [Bind loc a (Fix (TermF prim loc b))]
vs) Fix (TermF prim loc b)
a
        AssertType loc
loc Fix (TermF prim loc b)
r Type loc a
sig -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc b)
-> Type loc b
-> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> r -> Type loc v -> TermF prim loc v r
AssertType loc
loc Fix (TermF prim loc b)
r ((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
sig)
        Case loc
loc Fix (TermF prim loc b)
a [CaseAlt loc a (Fix (TermF prim loc b))]
alts -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc b)
-> [CaseAlt loc b (Fix (TermF prim loc b))]
-> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r.
loc -> r -> [CaseAlt loc v r] -> TermF prim loc v r
Case loc
loc Fix (TermF prim loc b)
a ([CaseAlt loc b (Fix (TermF prim loc b))]
 -> TermF prim loc b (Fix (TermF prim loc b)))
-> [CaseAlt loc b (Fix (TermF prim loc b))]
-> TermF prim loc b (Fix (TermF prim loc b))
forall a b. (a -> b) -> a -> b
$ (CaseAlt loc a (Fix (TermF prim loc b))
 -> CaseAlt loc b (Fix (TermF prim loc b)))
-> [CaseAlt loc a (Fix (TermF prim loc b))]
-> [CaseAlt loc b (Fix (TermF prim loc b))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b)
-> CaseAlt loc a (Fix (TermF prim loc b))
-> CaseAlt loc b (Fix (TermF prim loc b))
mapAlt a -> b
f) [CaseAlt loc a (Fix (TermF prim loc b))]
alts
        Constr loc
loc Type loc a
ty a
v -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc -> Type loc b -> b -> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> Type loc v -> v -> TermF prim loc v r
Constr loc
loc ((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) (a -> b
f a
v)
        Bottom loc
loc -> TermF prim loc b (Fix (TermF prim loc b)) -> Fix (TermF prim loc b)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc b (Fix (TermF prim loc b))
 -> Fix (TermF prim loc b))
-> TermF prim loc b (Fix (TermF prim loc b))
-> Fix (TermF prim loc b)
forall a b. (a -> b) -> a -> b
$ loc -> TermF prim loc b (Fix (TermF prim loc b))
forall prim loc v r. loc -> TermF prim loc v r
Bottom loc
loc

      mapAlt :: (a -> b)
-> CaseAlt loc a (Fix (TermF prim loc b))
-> CaseAlt loc b (Fix (TermF prim loc b))
mapAlt a -> b
g alt :: CaseAlt loc a (Fix (TermF prim loc b))
alt@CaseAlt{loc
a
[Typed loc a (loc, a)]
Fix (TermF prim loc b)
Type loc a
caseAlt'rhs :: Fix (TermF prim loc b)
caseAlt'constrType :: Type loc a
caseAlt'args :: [Typed loc a (loc, a)]
caseAlt'tag :: a
caseAlt'loc :: loc
caseAlt'rhs :: forall loc v a. CaseAlt loc v a -> a
caseAlt'constrType :: forall loc v a. CaseAlt loc v a -> Type loc v
caseAlt'args :: forall loc v a. CaseAlt loc v a -> [Typed loc v (loc, v)]
caseAlt'tag :: forall loc v a. CaseAlt loc v a -> v
caseAlt'loc :: forall loc v a. CaseAlt loc v a -> loc
..} = CaseAlt loc a (Fix (TermF prim loc b))
alt
        { caseAlt'tag :: b
caseAlt'tag  = a -> b
f a
caseAlt'tag
        , caseAlt'args :: [Typed loc b (loc, b)]
caseAlt'args = (Typed loc a (loc, a) -> Typed loc b (loc, b))
-> [Typed loc a (loc, a)] -> [Typed loc b (loc, b)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Typed loc a (loc, a) -> Typed loc b (loc, b)
mapTyped a -> b
g) [Typed loc a (loc, a)]
caseAlt'args
        , caseAlt'constrType :: Type loc b
caseAlt'constrType = (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
caseAlt'constrType
        }

      mapTyped :: (a -> b) -> Typed loc a (loc, a) -> Typed loc b (loc, b)
mapTyped a -> b
g Typed{(loc, a)
Type loc a
typed'value :: forall loc v a. Typed loc v a -> a
typed'type :: forall loc v a. Typed loc v a -> Type loc v
typed'value :: (loc, a)
typed'type :: Type loc a
..} = Type loc b -> (loc, b) -> Typed loc b (loc, b)
forall loc v a. Type loc v -> a -> Typed loc v a
Typed ((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
typed'type) ((a -> b) -> (loc, a) -> (loc, b)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second a -> b
g (loc, a)
typed'value)

-- | 'varE' @loc x@ constructs a variable whose name is @x@ with source code at @loc@.
varE :: loc -> var -> Term prim loc var
varE :: loc -> var -> Term prim loc var
varE loc
loc = Fix (TermF prim loc var) -> Term prim loc var
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc var) -> Term prim loc var)
-> (var -> Fix (TermF prim loc var)) -> var -> Term prim loc var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc var (Fix (TermF prim loc var))
 -> Fix (TermF prim loc var))
-> (var -> TermF prim loc var (Fix (TermF prim loc var)))
-> var
-> Fix (TermF prim loc var)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. loc -> var -> TermF prim loc var (Fix (TermF prim loc var))
forall prim loc v r. loc -> v -> TermF prim loc v r
Var loc
loc

-- | `primE` @loc prim@ constructs a primitive with source code at @loc@.
primE :: loc -> prim -> Term prim loc var
primE :: loc -> prim -> Term prim loc var
primE loc
loc = Fix (TermF prim loc var) -> Term prim loc var
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc var) -> Term prim loc var)
-> (prim -> Fix (TermF prim loc var)) -> prim -> Term prim loc var
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc var (Fix (TermF prim loc var))
 -> Fix (TermF prim loc var))
-> (prim -> TermF prim loc var (Fix (TermF prim loc var)))
-> prim
-> Fix (TermF prim loc var)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. loc -> prim -> TermF prim loc var (Fix (TermF prim loc var))
forall prim loc v r. loc -> prim -> TermF prim loc v r
Prim loc
loc

-- | 'appE' @loc a b@ constructs an application of @a@ to @b@ with source code at @loc@.
appE :: loc -> Term prim loc v -> Term prim loc v -> Term prim loc v
appE :: loc -> Term prim loc v -> Term prim loc v -> Term prim loc v
appE loc
loc (Term Fix (TermF prim loc v)
l) (Term Fix (TermF prim loc v)
r) = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc v)
-> Fix (TermF prim loc v)
-> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r. loc -> r -> r -> TermF prim loc v r
App loc
loc Fix (TermF prim loc v)
l Fix (TermF prim loc v)
r

-- | 'lamE' @loc x e@ constructs an abstraction of @x@ over @e@ with source code at @loc@.
lamE :: loc -> v -> Term prim loc v -> Term prim loc v
lamE :: loc -> v -> Term prim loc v -> Term prim loc v
lamE loc
loc v
x (Term Fix (TermF prim loc v)
e) = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> v
-> Fix (TermF prim loc v)
-> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r. loc -> v -> r -> TermF prim loc v r
Lam loc
loc v
x Fix (TermF prim loc v)
e

-- | 'letE' @loc binds e@ constructs a binding of @binds@ in @e@ with source code at @loc@.
-- No recursive bindings.
letE :: loc -> Bind loc v (Term prim loc v) -> Term prim loc v -> Term prim loc v
letE :: loc
-> Bind loc v (Term prim loc v)
-> Term prim loc v
-> Term prim loc v
letE loc
loc Bind loc v (Term prim loc v)
bind (Term Fix (TermF prim loc v)
e) = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> Bind loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
-> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r. loc -> Bind loc v r -> r -> TermF prim loc v r
Let loc
loc ((Term prim loc v -> Fix (TermF prim loc v))
-> Bind loc v (Term prim loc v)
-> Bind loc v (Fix (TermF prim loc v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Term prim loc v -> Fix (TermF prim loc v)
forall prim loc v. Term prim loc v -> Fix (TermF prim loc v)
unTerm Bind loc v (Term prim loc v)
bind) Fix (TermF prim loc v)
e

-- | 'letRecE' @loc binds e@ constructs a recursive binding of @binds@ in @e@ with source code at @loc@.
letRecE :: loc -> [Bind loc v (Term prim loc v)] -> Term prim loc v -> Term prim loc v
letRecE :: loc
-> [Bind loc v (Term prim loc v)]
-> Term prim loc v
-> Term prim loc v
letRecE loc
loc [Bind loc v (Term prim loc v)]
binds (Term Fix (TermF prim loc v)
e) = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> [Bind loc v (Fix (TermF prim loc v))]
-> Fix (TermF prim loc v)
-> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r.
loc -> [Bind loc v r] -> r -> TermF prim loc v r
LetRec loc
loc ((Bind loc v (Term prim loc v)
 -> Bind loc v (Fix (TermF prim loc v)))
-> [Bind loc v (Term prim loc v)]
-> [Bind loc v (Fix (TermF prim loc v))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Term prim loc v -> Fix (TermF prim loc v))
-> Bind loc v (Term prim loc v)
-> Bind loc v (Fix (TermF prim loc v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Term prim loc v -> Fix (TermF prim loc v)
forall prim loc v. Term prim loc v -> Fix (TermF prim loc v)
unTerm) [Bind loc v (Term prim loc v)]
binds) Fix (TermF prim loc v)
e

-- | 'assertTypeE' @loc term ty@ constructs assertion of the type @ty@ to @term@.
assertTypeE :: loc -> Term prim loc v -> Type loc v -> Term prim loc v
assertTypeE :: loc -> Term prim loc v -> Type loc v -> Term prim loc v
assertTypeE loc
loc (Term Fix (TermF prim loc v)
a) Type loc v
ty = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc v)
-> Type loc v
-> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r. loc -> r -> Type loc v -> TermF prim loc v r
AssertType loc
loc Fix (TermF prim loc v)
a Type loc v
ty

-- | 'caseE' @loc expr alts@ constructs case alternatives expression.
caseE :: loc -> Term prim loc v -> [CaseAlt loc v (Term prim loc v)] -> Term prim loc v
caseE :: loc
-> Term prim loc v
-> [CaseAlt loc v (Term prim loc v)]
-> Term prim loc v
caseE loc
loc (Term Fix (TermF prim loc v)
e) [CaseAlt loc v (Term prim loc v)]
alts = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc v)
-> [CaseAlt loc v (Fix (TermF prim loc v))]
-> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r.
loc -> r -> [CaseAlt loc v r] -> TermF prim loc v r
Case loc
loc Fix (TermF prim loc v)
e ([CaseAlt loc v (Fix (TermF prim loc v))]
 -> TermF prim loc v (Fix (TermF prim loc v)))
-> [CaseAlt loc v (Fix (TermF prim loc v))]
-> TermF prim loc v (Fix (TermF prim loc v))
forall a b. (a -> b) -> a -> b
$ (CaseAlt loc v (Term prim loc v)
 -> CaseAlt loc v (Fix (TermF prim loc v)))
-> [CaseAlt loc v (Term prim loc v)]
-> [CaseAlt loc v (Fix (TermF prim loc v))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Term prim loc v -> Fix (TermF prim loc v))
-> CaseAlt loc v (Term prim loc v)
-> CaseAlt loc v (Fix (TermF prim loc v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Term prim loc v -> Fix (TermF prim loc v)
forall prim loc v. Term prim loc v -> Fix (TermF prim loc v)
unTerm) [CaseAlt loc v (Term prim loc v)]
alts

-- | 'constrE' @loc ty tag arity@ constructs constructor tag expression.
constrE :: loc -> Type loc v -> v -> Term prim loc v
constrE :: loc -> Type loc v -> v -> Term prim loc v
constrE loc
loc Type loc v
ty v
tag = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc -> Type loc v -> v -> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r. loc -> Type loc v -> v -> TermF prim loc v r
Constr loc
loc Type loc v
ty v
tag

-- | 'bottomE' @loc@ constructs bottom value.
bottomE :: loc -> Term prim loc v
bottomE :: loc -> Term prim loc v
bottomE loc
loc = Fix (TermF prim loc v) -> Term prim loc v
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc v) -> Term prim loc v)
-> Fix (TermF prim loc v) -> Term prim loc v
forall a b. (a -> b) -> a -> b
$ TermF prim loc v (Fix (TermF prim loc v)) -> Fix (TermF prim loc v)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc v (Fix (TermF prim loc v))
 -> Fix (TermF prim loc v))
-> TermF prim loc v (Fix (TermF prim loc v))
-> Fix (TermF prim loc v)
forall a b. (a -> b) -> a -> b
$ loc -> TermF prim loc v (Fix (TermF prim loc v))
forall prim loc v r. loc -> TermF prim loc v r
Bottom loc
loc

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

instance HasLoc (Term prim loc v) where
  type Loc (Term prim loc v) = loc

  getLoc :: Term prim loc v -> Loc (Term prim loc v)
getLoc (Term (Fix TermF prim loc v (Fix (TermF prim loc v))
x)) = case TermF prim loc v (Fix (TermF prim loc v))
x of
    Var loc
loc v
_   -> loc
Loc (Term prim loc v)
loc
    Prim loc
loc prim
_  -> loc
Loc (Term prim loc v)
loc
    App loc
loc Fix (TermF prim loc v)
_ Fix (TermF prim loc v)
_ -> loc
Loc (Term prim loc v)
loc
    Lam loc
loc v
_ Fix (TermF prim loc v)
_ -> loc
Loc (Term prim loc v)
loc
    Let loc
loc Bind loc v (Fix (TermF prim loc v))
_ Fix (TermF prim loc v)
_ -> loc
Loc (Term prim loc v)
loc
    LetRec loc
loc [Bind loc v (Fix (TermF prim loc v))]
_ Fix (TermF prim loc v)
_ -> loc
Loc (Term prim loc v)
loc
    AssertType loc
loc Fix (TermF prim loc v)
_ Type loc v
_ -> loc
Loc (Term prim loc v)
loc
    Constr loc
loc Type loc v
_ v
_ -> loc
Loc (Term prim loc v)
loc
    Case loc
loc Fix (TermF prim loc v)
_ [CaseAlt loc v (Fix (TermF prim loc v))]
_ -> loc
Loc (Term prim loc v)
loc
    Bottom loc
loc -> loc
Loc (Term prim loc v)
loc

instance LocFunctor (Term prim) where
  mapLoc :: (locA -> locB) -> Term prim locA var -> Term prim locB var
mapLoc locA -> locB
f (Term Fix (TermF prim locA var)
x) = Fix (TermF prim locB var) -> Term prim locB var
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim locB var) -> Term prim locB var)
-> Fix (TermF prim locB var) -> Term prim locB var
forall a b. (a -> b) -> a -> b
$ (TermF prim locA var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> Fix (TermF prim locA var) -> Fix (TermF prim locB var)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TermF prim locA var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
go Fix (TermF prim locA var)
x
    where
      go :: TermF prim locA var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
go = \case
        Var locA
loc var
v    -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB -> var -> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> v -> TermF prim loc v r
Var (locA -> locB
f locA
loc) var
v
        Prim locA
loc prim
p   -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB -> prim -> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> prim -> TermF prim loc v r
Prim (locA -> locB
f locA
loc) prim
p
        App locA
loc Fix (TermF prim locB var)
a Fix (TermF prim locB var)
b  -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Fix (TermF prim locB var)
-> Fix (TermF prim locB var)
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> r -> r -> TermF prim loc v r
App (locA -> locB
f locA
loc) Fix (TermF prim locB var)
a Fix (TermF prim locB var)
b
        Lam locA
loc var
v Fix (TermF prim locB var)
a  -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> var
-> Fix (TermF prim locB var)
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> v -> r -> TermF prim loc v r
Lam (locA -> locB
f locA
loc) var
v Fix (TermF prim locB var)
a
        Let locA
loc Bind locA var (Fix (TermF prim locB var))
v Fix (TermF prim locB var)
a  -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Bind locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> Bind loc v r -> r -> TermF prim loc v r
Let (locA -> locB
f locA
loc) (Bind locA var (Fix (TermF prim locB var))
v { bind'loc :: locB
bind'loc = locA -> locB
f (locA -> locB) -> locA -> locB
forall a b. (a -> b) -> a -> b
$ Bind locA var (Fix (TermF prim locB var)) -> locA
forall loc var r. Bind loc var r -> loc
bind'loc Bind locA var (Fix (TermF prim locB var))
v }) Fix (TermF prim locB var)
a
        LetRec locA
loc [Bind locA var (Fix (TermF prim locB var))]
vs Fix (TermF prim locB var)
a -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> [Bind locB var (Fix (TermF prim locB var))]
-> Fix (TermF prim locB var)
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r.
loc -> [Bind loc v r] -> r -> TermF prim loc v r
LetRec (locA -> locB
f locA
loc) ((Bind locA var (Fix (TermF prim locB var))
 -> Bind locB var (Fix (TermF prim locB var)))
-> [Bind locA var (Fix (TermF prim locB var))]
-> [Bind locB var (Fix (TermF prim locB var))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Bind locA var (Fix (TermF prim locB var))
b ->  Bind locA var (Fix (TermF prim locB var))
b { bind'loc :: locB
bind'loc = locA -> locB
f (locA -> locB) -> locA -> locB
forall a b. (a -> b) -> a -> b
$ Bind locA var (Fix (TermF prim locB var)) -> locA
forall loc var r. Bind loc var r -> loc
bind'loc Bind locA var (Fix (TermF prim locB var))
b }) [Bind locA var (Fix (TermF prim locB var))]
vs) Fix (TermF prim locB var)
a
        AssertType locA
loc Fix (TermF prim locB var)
r Type locA var
sig -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Fix (TermF prim locB var)
-> Type locB var
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> r -> Type loc v -> TermF prim loc v r
AssertType (locA -> locB
f locA
loc) Fix (TermF prim locB var)
r ((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
sig)
        Constr locA
loc Type locA var
ty var
v -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Type locB var
-> var
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> Type loc v -> v -> TermF prim loc v r
Constr (locA -> locB
f locA
loc) ((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) var
v
        Case locA
loc Fix (TermF prim locB var)
e [CaseAlt locA var (Fix (TermF prim locB var))]
alts -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB
-> Fix (TermF prim locB var)
-> [CaseAlt locB var (Fix (TermF prim locB var))]
-> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r.
loc -> r -> [CaseAlt loc v r] -> TermF prim loc v r
Case (locA -> locB
f locA
loc) Fix (TermF prim locB var)
e ((CaseAlt locA var (Fix (TermF prim locB var))
 -> CaseAlt locB var (Fix (TermF prim locB var)))
-> [CaseAlt locA var (Fix (TermF prim locB var))]
-> [CaseAlt locB var (Fix (TermF prim locB var))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CaseAlt locA var (Fix (TermF prim locB var))
-> CaseAlt locB var (Fix (TermF prim locB var))
mapAlt [CaseAlt locA var (Fix (TermF prim locB var))]
alts)
        Bottom locA
loc -> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim locB var (Fix (TermF prim locB var))
 -> Fix (TermF prim locB var))
-> TermF prim locB var (Fix (TermF prim locB var))
-> Fix (TermF prim locB var)
forall a b. (a -> b) -> a -> b
$ locB -> TermF prim locB var (Fix (TermF prim locB var))
forall prim loc v r. loc -> TermF prim loc v r
Bottom (locA -> locB
f locA
loc)

      mapAlt :: CaseAlt locA var (Fix (TermF prim locB var))
-> CaseAlt locB var (Fix (TermF prim locB var))
mapAlt alt :: CaseAlt locA var (Fix (TermF prim locB var))
alt@CaseAlt{locA
var
[Typed locA var (locA, var)]
Fix (TermF prim locB var)
Type locA var
caseAlt'rhs :: Fix (TermF prim locB var)
caseAlt'constrType :: Type locA var
caseAlt'args :: [Typed locA var (locA, var)]
caseAlt'tag :: var
caseAlt'loc :: locA
caseAlt'rhs :: forall loc v a. CaseAlt loc v a -> a
caseAlt'constrType :: forall loc v a. CaseAlt loc v a -> Type loc v
caseAlt'args :: forall loc v a. CaseAlt loc v a -> [Typed loc v (loc, v)]
caseAlt'tag :: forall loc v a. CaseAlt loc v a -> v
caseAlt'loc :: forall loc v a. CaseAlt loc v a -> loc
..} = CaseAlt locA var (Fix (TermF prim locB var))
alt
        { caseAlt'loc :: locB
caseAlt'loc  = locA -> locB
f locA
caseAlt'loc
        , caseAlt'args :: [Typed locB var (locB, var)]
caseAlt'args = (Typed locA var (locA, var) -> Typed locB var (locB, var))
-> [Typed locA var (locA, var)] -> [Typed locB var (locB, var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Typed locA var (locA, var) -> Typed locB var (locB, var)
mapTyped [Typed locA var (locA, var)]
caseAlt'args
        , caseAlt'constrType :: Type locB var
caseAlt'constrType = (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
caseAlt'constrType
        }

      mapTyped :: Typed locA var (locA, var) -> Typed locB var (locB, var)
mapTyped (Typed Type locA var
ty (locA, var)
val) = Type locB var -> (locB, var) -> Typed locB var (locB, var)
forall loc v a. Type loc v -> a -> Typed loc v a
Typed ((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) ((locA -> locB) -> (locA, var) -> (locB, var)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first locA -> locB
f (locA, var)
val)

-- | Get free variables of the term.
freeVars :: Ord v => Term lprim oc v -> Set v
freeVars :: Term lprim oc v -> Set v
freeVars = (TermF lprim oc v (Set v) -> Set v)
-> Fix (TermF lprim oc v) -> Set v
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TermF lprim oc v (Set v) -> Set v
go (Fix (TermF lprim oc v) -> Set v)
-> (Term lprim oc v -> Fix (TermF lprim oc v))
-> Term lprim oc v
-> Set v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term lprim oc v -> Fix (TermF lprim oc v)
forall prim loc v. Term prim loc v -> Fix (TermF prim loc v)
unTerm
  where
    go :: TermF lprim oc v (Set v) -> Set v
go = \case
      Var    oc
_ v
v          -> v -> Set v
forall a. a -> Set a
S.singleton v
v
      Prim   oc
_ lprim
_          -> Set v
forall a. Monoid a => a
mempty
      App    oc
_ Set v
a Set v
b        -> Set v -> Set v -> Set v
forall a. Monoid a => a -> a -> a
mappend Set v
a Set v
b
      Lam    oc
_ v
v Set v
a        -> v -> Set v -> Set v
forall a. Ord a => a -> Set a -> Set a
S.delete v
v Set v
a
      Let    oc
_ Bind oc v (Set v)
bind Set v
body  -> let lhs :: Set v
lhs = v -> Set v
forall a. a -> Set a
S.singleton (v -> Set v) -> v -> Set v
forall a b. (a -> b) -> a -> b
$ Bind oc v (Set v) -> v
forall loc var r. Bind loc var r -> var
bind'lhs Bind oc v (Set v)
bind
                             in  Set v -> Set v -> Set v
forall a. Monoid a => a -> a -> a
mappend (Bind oc v (Set v) -> Set v
forall loc var r. Bind loc var r -> r
bind'rhs Bind oc v (Set v)
bind)
                                         (Set v
body Set v -> Set v -> Set v
forall a. Ord a => Set a -> Set a -> Set a
`S.difference` Set v
lhs)
      LetRec oc
_ [Bind oc v (Set v)]
binds Set v
body -> let lhs :: Set v
lhs = [v] -> Set v
forall a. Ord a => [a] -> Set a
S.fromList ([v] -> Set v) -> [v] -> Set v
forall a b. (a -> b) -> a -> b
$ (Bind oc v (Set v) -> v) -> [Bind oc v (Set v)] -> [v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bind oc v (Set v) -> v
forall loc var r. Bind loc var r -> var
bind'lhs [Bind oc v (Set v)]
binds
                             in  (Set v -> Set v -> Set v
forall a. Monoid a => a -> a -> a
mappend ([Bind oc v (Set v)] -> Set v
forall loc var. [Bind loc var (Set v)] -> Set v
freeBinds [Bind oc v (Set v)]
binds) Set v
body) Set v -> Set v -> Set v
forall a. Ord a => Set a -> Set a -> Set a
`S.difference` Set v
lhs
      AssertType oc
_ Set v
a Type oc v
_    -> Set v
a
      Case oc
_ Set v
e [CaseAlt oc v (Set v)]
alts       -> Set v -> Set v -> Set v
forall a. Monoid a => a -> a -> a
mappend Set v
e ((CaseAlt oc v (Set v) -> Set v) -> [CaseAlt oc v (Set v)] -> Set v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap CaseAlt oc v (Set v) -> Set v
forall a a. Ord a => CaseAlt a a (Set a) -> Set a
freeVarAlts [CaseAlt oc v (Set v)]
alts)
      Constr oc
_ Type oc v
_ v
_        -> Set v
forall a. Monoid a => a
mempty
      Bottom oc
_            -> Set v
forall a. Monoid a => a
mempty

    freeBinds :: [Bind loc var (Set v)] -> Set v
freeBinds = (Bind loc var (Set v) -> Set v) -> [Bind loc var (Set v)] -> Set v
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bind loc var (Set v) -> Set v
forall loc var r. Bind loc var r -> r
bind'rhs

    freeVarAlts :: CaseAlt a a (Set a) -> Set a
freeVarAlts CaseAlt{a
a
[Typed a a (a, a)]
Set a
Type a a
caseAlt'rhs :: Set a
caseAlt'constrType :: Type a a
caseAlt'args :: [Typed a a (a, a)]
caseAlt'tag :: a
caseAlt'loc :: a
caseAlt'rhs :: forall loc v a. CaseAlt loc v a -> a
caseAlt'constrType :: forall loc v a. CaseAlt loc v a -> Type loc v
caseAlt'args :: forall loc v a. CaseAlt loc v a -> [Typed loc v (loc, v)]
caseAlt'tag :: forall loc v a. CaseAlt loc v a -> v
caseAlt'loc :: forall loc v a. CaseAlt loc v a -> loc
..} = Set a
caseAlt'rhs Set a -> Set a -> Set a
forall a. Ord a => Set a -> Set a -> Set a
`S.difference` ([a] -> Set a
forall a. Ord a => [a] -> Set a
S.fromList ([a] -> Set a) -> [a] -> Set a
forall a b. (a -> b) -> a -> b
$ (Typed a a (a, a) -> a) -> [Typed a a (a, a)] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a, a) -> a
forall a b. (a, b) -> b
snd ((a, a) -> a)
-> (Typed a a (a, a) -> (a, a)) -> Typed a a (a, a) -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Typed a a (a, a) -> (a, a)
forall loc v a. Typed loc v a -> a
typed'value) [Typed a a (a, a)]
caseAlt'args)

instance TypeFunctor (Term prim) where
  mapType :: (Type loc var -> Type loc var)
-> Term prim loc var -> Term prim loc var
mapType Type loc var -> Type loc var
f (Term Fix (TermF prim loc var)
term) = Fix (TermF prim loc var) -> Term prim loc var
forall prim loc v. Fix (TermF prim loc v) -> Term prim loc v
Term (Fix (TermF prim loc var) -> Term prim loc var)
-> Fix (TermF prim loc var) -> Term prim loc var
forall a b. (a -> b) -> a -> b
$ (TermF prim loc var (Fix (TermF prim loc var))
 -> Fix (TermF prim loc var))
-> Fix (TermF prim loc var) -> Fix (TermF prim loc var)
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
go Fix (TermF prim loc var)
term
    where
      go :: TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
go = \case
        Constr loc
loc Type loc var
ty var
cons       -> TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc var (Fix (TermF prim loc var))
 -> Fix (TermF prim loc var))
-> TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall a b. (a -> b) -> a -> b
$ loc
-> Type loc var
-> var
-> TermF prim loc var (Fix (TermF prim loc var))
forall prim loc v r. loc -> Type loc v -> v -> TermF prim loc v r
Constr loc
loc (Type loc var -> Type loc var
f Type loc var
ty) var
cons
        Case loc
loc Fix (TermF prim loc var)
e [CaseAlt loc var (Fix (TermF prim loc var))]
alts          -> TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (TermF prim loc var (Fix (TermF prim loc var))
 -> Fix (TermF prim loc var))
-> TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall a b. (a -> b) -> a -> b
$ loc
-> Fix (TermF prim loc var)
-> [CaseAlt loc var (Fix (TermF prim loc var))]
-> TermF prim loc var (Fix (TermF prim loc var))
forall prim loc v r.
loc -> r -> [CaseAlt loc v r] -> TermF prim loc v r
Case loc
loc Fix (TermF prim loc var)
e ([CaseAlt loc var (Fix (TermF prim loc var))]
 -> TermF prim loc var (Fix (TermF prim loc var)))
-> [CaseAlt loc var (Fix (TermF prim loc var))]
-> TermF prim loc var (Fix (TermF prim loc var))
forall a b. (a -> b) -> a -> b
$ (CaseAlt loc var (Fix (TermF prim loc var))
 -> CaseAlt loc var (Fix (TermF prim loc var)))
-> [CaseAlt loc var (Fix (TermF prim loc var))]
-> [CaseAlt loc var (Fix (TermF prim loc var))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CaseAlt loc var (Fix (TermF prim loc var))
-> CaseAlt loc var (Fix (TermF prim loc var))
applyAlt [CaseAlt loc var (Fix (TermF prim loc var))]
alts
        TermF prim loc var (Fix (TermF prim loc var))
other                    -> TermF prim loc var (Fix (TermF prim loc var))
-> Fix (TermF prim loc var)
forall (f :: * -> *). f (Fix f) -> Fix f
Fix TermF prim loc var (Fix (TermF prim loc var))
other

      applyAlt :: CaseAlt loc var (Fix (TermF prim loc var))
-> CaseAlt loc var (Fix (TermF prim loc var))
applyAlt alt :: CaseAlt loc var (Fix (TermF prim loc var))
alt@CaseAlt{loc
var
[Typed loc var (loc, var)]
Fix (TermF prim loc var)
Type loc var
caseAlt'rhs :: Fix (TermF prim loc var)
caseAlt'constrType :: Type loc var
caseAlt'args :: [Typed loc var (loc, var)]
caseAlt'tag :: var
caseAlt'loc :: loc
caseAlt'rhs :: forall loc v a. CaseAlt loc v a -> a
caseAlt'constrType :: forall loc v a. CaseAlt loc v a -> Type loc v
caseAlt'args :: forall loc v a. CaseAlt loc v a -> [Typed loc v (loc, v)]
caseAlt'tag :: forall loc v a. CaseAlt loc v a -> v
caseAlt'loc :: forall loc v a. CaseAlt loc v a -> loc
..} = CaseAlt loc var (Fix (TermF prim loc var))
alt
        { caseAlt'args :: [Typed loc var (loc, var)]
caseAlt'args       = (Typed loc var (loc, var) -> Typed loc var (loc, var))
-> [Typed loc var (loc, var)] -> [Typed loc var (loc, var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Typed loc var (loc, var) -> Typed loc var (loc, var)
applyTyped [Typed loc var (loc, var)]
caseAlt'args
        , caseAlt'constrType :: Type loc var
caseAlt'constrType = Type loc var -> Type loc var
f Type loc var
caseAlt'constrType
        }

      applyTyped :: Typed loc var (loc, var) -> Typed loc var (loc, var)
applyTyped ty :: Typed loc var (loc, var)
ty@Typed{(loc, var)
Type loc var
typed'value :: (loc, var)
typed'type :: Type loc var
typed'value :: forall loc v a. Typed loc v a -> a
typed'type :: forall loc v a. Typed loc v a -> Type loc v
..} = Typed loc var (loc, var)
ty { typed'type :: Type loc var
typed'type = Type loc var -> Type loc var
f Type loc var
typed'type }

instance CanApply (Term prim) where
  apply :: Subst loc v -> Term prim loc v -> Term prim loc v
apply Subst loc v
subst Term prim loc v
term = (Type loc v -> Type loc v) -> Term prim loc v -> Term prim loc v
forall (f :: * -> * -> *) loc var.
TypeFunctor f =>
(Type loc var -> Type loc var) -> f loc var -> f loc var
mapType (Subst loc v -> Type loc v -> Type loc v
forall (f :: * -> * -> *) v loc.
(CanApply f, Ord v) =>
Subst loc v -> f loc v -> f loc v
apply Subst loc v
subst) Term prim loc v
term