{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ViewPatterns #-}

-- | Sslang's intermediate representation and its associated helpers.
module IR.IR (
  Program (..),
  SymInfo (..),
  TypeDef (..),
  TypeVariant (..),
  Binder (..),
  Literal (..),
  PrimOp (..),
  Primitive (..),
  Expr (..),
  Alt (..),
  VarId (..),
  TConId (..),
  DConId (..),
  ExceptType (..),
  Type,
  Annotation,
  Annotations,
  variantFields,
  foldLambda,
  unfoldLambda,
  extract,
  inject,
  injectMore,
  foldApp,
  unfoldApp,
  isValue,
  altBinders,
  pattern BindVar,
  pattern BindAnon,
  binderToVar,
  Carrier,
  uninitializedSymTable,
  SymTable,
) where

import Common.Identifiers (
  CSym (..),
  DConId (..),
  HasFreeVars (..),
  TConId (..),
  TVarId (..),
  VarId (..),
 )
import Data.Data (
  Data,
  Typeable,
 )

import qualified Data.Map as M
import Data.Maybe (
  catMaybes,
  mapMaybe,
  maybeToList,
 )
import Data.Set ((\\))
import qualified Data.Set as S
import IR.Types.Type (
  Annotation,
  Annotations,
  Type,
  pattern Arrow,
 )


-- | Top-level compilation unit, parameterized by the type system.
data Program t = Program
  { Program t -> VarId
programEntry :: VarId
  , Program t -> String
cDefs :: String
  , Program t -> [(VarId, Type)]
externDecls :: [(VarId, Type)]
  , Program t -> [(Binder t, Expr t)]
programDefs :: [(Binder t, Expr t)]
  , Program t -> [(TConId, TypeDef)]
typeDefs :: [(TConId, TypeDef)]
  , Program t -> Map VarId (SymInfo t)
symTable :: M.Map VarId (SymInfo t)
  }
  deriving (Program t -> Program t -> Bool
(Program t -> Program t -> Bool)
-> (Program t -> Program t -> Bool) -> Eq (Program t)
forall t. Eq t => Program t -> Program t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Program t -> Program t -> Bool
$c/= :: forall t. Eq t => Program t -> Program t -> Bool
== :: Program t -> Program t -> Bool
$c== :: forall t. Eq t => Program t -> Program t -> Bool
Eq, Int -> Program t -> ShowS
[Program t] -> ShowS
Program t -> String
(Int -> Program t -> ShowS)
-> (Program t -> String)
-> ([Program t] -> ShowS)
-> Show (Program t)
forall t. Show t => Int -> Program t -> ShowS
forall t. Show t => [Program t] -> ShowS
forall t. Show t => Program t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Program t] -> ShowS
$cshowList :: forall t. Show t => [Program t] -> ShowS
show :: Program t -> String
$cshow :: forall t. Show t => Program t -> String
showsPrec :: Int -> Program t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Program t -> ShowS
Show, Typeable, Typeable (Program t)
DataType
Constr
Typeable (Program t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Program t -> c (Program t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Program t))
-> (Program t -> Constr)
-> (Program t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Program t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Program t)))
-> ((forall b. Data b => b -> b) -> Program t -> Program t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Program t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Program t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Program t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Program t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Program t -> m (Program t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Program t -> m (Program t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Program t -> m (Program t))
-> Data (Program t)
Program t -> DataType
Program t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Program t))
(forall b. Data b => b -> b) -> Program t -> Program t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program t -> c (Program t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Program t)
forall t. Data t => Typeable (Program t)
forall t. Data t => Program t -> DataType
forall t. Data t => Program t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Program t -> Program t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Program t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Program t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Program t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program t -> c (Program t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Program t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Program t))
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) -> Program t -> u
forall u. (forall d. Data d => d -> u) -> Program t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Program t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program t -> c (Program t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Program t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Program t))
$cProgram :: Constr
$tProgram :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Program t -> m (Program t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
gmapMp :: (forall d. Data d => d -> m d) -> Program t -> m (Program t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
gmapM :: (forall d. Data d => d -> m d) -> Program t -> m (Program t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Program t -> m (Program t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Program t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Program t -> u
gmapQ :: (forall d. Data d => d -> u) -> Program t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Program t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program t -> r
gmapT :: (forall b. Data b => b -> b) -> Program t -> Program t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Program t -> Program t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Program t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Program t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Program t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Program t))
dataTypeOf :: Program t -> DataType
$cdataTypeOf :: forall t. Data t => Program t -> DataType
toConstr :: Program t -> Constr
$ctoConstr :: forall t. Data t => Program t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Program t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Program t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program t -> c (Program t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program t -> c (Program t)
$cp1Data :: forall t. Data t => Typeable (Program t)
Data, a -> Program b -> Program a
(a -> b) -> Program a -> Program b
(forall a b. (a -> b) -> Program a -> Program b)
-> (forall a b. a -> Program b -> Program a) -> Functor Program
forall a b. a -> Program b -> Program a
forall a b. (a -> b) -> Program a -> Program b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Program b -> Program a
$c<$ :: forall a b. a -> Program b -> Program a
fmap :: (a -> b) -> Program a -> Program b
$cfmap :: forall a b. (a -> b) -> Program a -> Program b
Functor, Program a -> Bool
(a -> m) -> Program a -> m
(a -> b -> b) -> b -> Program a -> b
(forall m. Monoid m => Program m -> m)
-> (forall m a. Monoid m => (a -> m) -> Program a -> m)
-> (forall m a. Monoid m => (a -> m) -> Program a -> m)
-> (forall a b. (a -> b -> b) -> b -> Program a -> b)
-> (forall a b. (a -> b -> b) -> b -> Program a -> b)
-> (forall b a. (b -> a -> b) -> b -> Program a -> b)
-> (forall b a. (b -> a -> b) -> b -> Program a -> b)
-> (forall a. (a -> a -> a) -> Program a -> a)
-> (forall a. (a -> a -> a) -> Program a -> a)
-> (forall a. Program a -> [a])
-> (forall a. Program a -> Bool)
-> (forall a. Program a -> Int)
-> (forall a. Eq a => a -> Program a -> Bool)
-> (forall a. Ord a => Program a -> a)
-> (forall a. Ord a => Program a -> a)
-> (forall a. Num a => Program a -> a)
-> (forall a. Num a => Program a -> a)
-> Foldable Program
forall a. Eq a => a -> Program a -> Bool
forall a. Num a => Program a -> a
forall a. Ord a => Program a -> a
forall m. Monoid m => Program m -> m
forall a. Program a -> Bool
forall a. Program a -> Int
forall a. Program a -> [a]
forall a. (a -> a -> a) -> Program a -> a
forall m a. Monoid m => (a -> m) -> Program a -> m
forall b a. (b -> a -> b) -> b -> Program a -> b
forall a b. (a -> b -> b) -> b -> Program 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 :: Program a -> a
$cproduct :: forall a. Num a => Program a -> a
sum :: Program a -> a
$csum :: forall a. Num a => Program a -> a
minimum :: Program a -> a
$cminimum :: forall a. Ord a => Program a -> a
maximum :: Program a -> a
$cmaximum :: forall a. Ord a => Program a -> a
elem :: a -> Program a -> Bool
$celem :: forall a. Eq a => a -> Program a -> Bool
length :: Program a -> Int
$clength :: forall a. Program a -> Int
null :: Program a -> Bool
$cnull :: forall a. Program a -> Bool
toList :: Program a -> [a]
$ctoList :: forall a. Program a -> [a]
foldl1 :: (a -> a -> a) -> Program a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Program a -> a
foldr1 :: (a -> a -> a) -> Program a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Program a -> a
foldl' :: (b -> a -> b) -> b -> Program a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Program a -> b
foldl :: (b -> a -> b) -> b -> Program a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Program a -> b
foldr' :: (a -> b -> b) -> b -> Program a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Program a -> b
foldr :: (a -> b -> b) -> b -> Program a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Program a -> b
foldMap' :: (a -> m) -> Program a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Program a -> m
foldMap :: (a -> m) -> Program a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Program a -> m
fold :: Program m -> m
$cfold :: forall m. Monoid m => Program m -> m
Foldable, Functor Program
Foldable Program
Functor Program
-> Foldable Program
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Program a -> f (Program b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Program (f a) -> f (Program a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Program a -> m (Program b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Program (m a) -> m (Program a))
-> Traversable Program
(a -> f b) -> Program a -> f (Program 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 => Program (m a) -> m (Program a)
forall (f :: * -> *) a.
Applicative f =>
Program (f a) -> f (Program a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Program a -> m (Program b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Program a -> f (Program b)
sequence :: Program (m a) -> m (Program a)
$csequence :: forall (m :: * -> *) a. Monad m => Program (m a) -> m (Program a)
mapM :: (a -> m b) -> Program a -> m (Program b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Program a -> m (Program b)
sequenceA :: Program (f a) -> f (Program a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Program (f a) -> f (Program a)
traverse :: (a -> f b) -> Program a -> f (Program b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Program a -> f (Program b)
$cp2Traversable :: Foldable Program
$cp1Traversable :: Functor Program
Traversable)


{- | Contains information about all (globally unique) variable names.

Populated by name mangling pass.
-}
type SymTable t = M.Map VarId (SymInfo t)


-- | Information stored in global symbol table.
data SymInfo t = SymInfo
  { -- | Original name of symbol
    SymInfo t -> VarId
symOrigin :: VarId
  , -- | Type information of symbol
    SymInfo t -> t
symType :: t
  }
  deriving (SymInfo t -> SymInfo t -> Bool
(SymInfo t -> SymInfo t -> Bool)
-> (SymInfo t -> SymInfo t -> Bool) -> Eq (SymInfo t)
forall t. Eq t => SymInfo t -> SymInfo t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SymInfo t -> SymInfo t -> Bool
$c/= :: forall t. Eq t => SymInfo t -> SymInfo t -> Bool
== :: SymInfo t -> SymInfo t -> Bool
$c== :: forall t. Eq t => SymInfo t -> SymInfo t -> Bool
Eq, Int -> SymInfo t -> ShowS
[SymInfo t] -> ShowS
SymInfo t -> String
(Int -> SymInfo t -> ShowS)
-> (SymInfo t -> String)
-> ([SymInfo t] -> ShowS)
-> Show (SymInfo t)
forall t. Show t => Int -> SymInfo t -> ShowS
forall t. Show t => [SymInfo t] -> ShowS
forall t. Show t => SymInfo t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SymInfo t] -> ShowS
$cshowList :: forall t. Show t => [SymInfo t] -> ShowS
show :: SymInfo t -> String
$cshow :: forall t. Show t => SymInfo t -> String
showsPrec :: Int -> SymInfo t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> SymInfo t -> ShowS
Show, Typeable, Typeable (SymInfo t)
DataType
Constr
Typeable (SymInfo t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SymInfo t -> c (SymInfo t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SymInfo t))
-> (SymInfo t -> Constr)
-> (SymInfo t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SymInfo t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SymInfo t)))
-> ((forall b. Data b => b -> b) -> SymInfo t -> SymInfo t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SymInfo t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SymInfo t -> r)
-> (forall u. (forall d. Data d => d -> u) -> SymInfo t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SymInfo t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t))
-> Data (SymInfo t)
SymInfo t -> DataType
SymInfo t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (SymInfo t))
(forall b. Data b => b -> b) -> SymInfo t -> SymInfo t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymInfo t -> c (SymInfo t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SymInfo t)
forall t. Data t => Typeable (SymInfo t)
forall t. Data t => SymInfo t -> DataType
forall t. Data t => SymInfo t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> SymInfo t -> SymInfo t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> SymInfo t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> SymInfo t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SymInfo t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymInfo t -> c (SymInfo t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SymInfo t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SymInfo t))
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) -> SymInfo t -> u
forall u. (forall d. Data d => d -> u) -> SymInfo t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SymInfo t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymInfo t -> c (SymInfo t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SymInfo t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SymInfo t))
$cSymInfo :: Constr
$tSymInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
gmapMp :: (forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
gmapM :: (forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> SymInfo t -> m (SymInfo t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> SymInfo t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> SymInfo t -> u
gmapQ :: (forall d. Data d => d -> u) -> SymInfo t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> SymInfo t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymInfo t -> r
gmapT :: (forall b. Data b => b -> b) -> SymInfo t -> SymInfo t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> SymInfo t -> SymInfo t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SymInfo t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SymInfo t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (SymInfo t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SymInfo t))
dataTypeOf :: SymInfo t -> DataType
$cdataTypeOf :: forall t. Data t => SymInfo t -> DataType
toConstr :: SymInfo t -> Constr
$ctoConstr :: forall t. Data t => SymInfo t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SymInfo t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SymInfo t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymInfo t -> c (SymInfo t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymInfo t -> c (SymInfo t)
$cp1Data :: forall t. Data t => Typeable (SymInfo t)
Data, a -> SymInfo b -> SymInfo a
(a -> b) -> SymInfo a -> SymInfo b
(forall a b. (a -> b) -> SymInfo a -> SymInfo b)
-> (forall a b. a -> SymInfo b -> SymInfo a) -> Functor SymInfo
forall a b. a -> SymInfo b -> SymInfo a
forall a b. (a -> b) -> SymInfo a -> SymInfo b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SymInfo b -> SymInfo a
$c<$ :: forall a b. a -> SymInfo b -> SymInfo a
fmap :: (a -> b) -> SymInfo a -> SymInfo b
$cfmap :: forall a b. (a -> b) -> SymInfo a -> SymInfo b
Functor, SymInfo a -> Bool
(a -> m) -> SymInfo a -> m
(a -> b -> b) -> b -> SymInfo a -> b
(forall m. Monoid m => SymInfo m -> m)
-> (forall m a. Monoid m => (a -> m) -> SymInfo a -> m)
-> (forall m a. Monoid m => (a -> m) -> SymInfo a -> m)
-> (forall a b. (a -> b -> b) -> b -> SymInfo a -> b)
-> (forall a b. (a -> b -> b) -> b -> SymInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> SymInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> SymInfo a -> b)
-> (forall a. (a -> a -> a) -> SymInfo a -> a)
-> (forall a. (a -> a -> a) -> SymInfo a -> a)
-> (forall a. SymInfo a -> [a])
-> (forall a. SymInfo a -> Bool)
-> (forall a. SymInfo a -> Int)
-> (forall a. Eq a => a -> SymInfo a -> Bool)
-> (forall a. Ord a => SymInfo a -> a)
-> (forall a. Ord a => SymInfo a -> a)
-> (forall a. Num a => SymInfo a -> a)
-> (forall a. Num a => SymInfo a -> a)
-> Foldable SymInfo
forall a. Eq a => a -> SymInfo a -> Bool
forall a. Num a => SymInfo a -> a
forall a. Ord a => SymInfo a -> a
forall m. Monoid m => SymInfo m -> m
forall a. SymInfo a -> Bool
forall a. SymInfo a -> Int
forall a. SymInfo a -> [a]
forall a. (a -> a -> a) -> SymInfo a -> a
forall m a. Monoid m => (a -> m) -> SymInfo a -> m
forall b a. (b -> a -> b) -> b -> SymInfo a -> b
forall a b. (a -> b -> b) -> b -> SymInfo 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 :: SymInfo a -> a
$cproduct :: forall a. Num a => SymInfo a -> a
sum :: SymInfo a -> a
$csum :: forall a. Num a => SymInfo a -> a
minimum :: SymInfo a -> a
$cminimum :: forall a. Ord a => SymInfo a -> a
maximum :: SymInfo a -> a
$cmaximum :: forall a. Ord a => SymInfo a -> a
elem :: a -> SymInfo a -> Bool
$celem :: forall a. Eq a => a -> SymInfo a -> Bool
length :: SymInfo a -> Int
$clength :: forall a. SymInfo a -> Int
null :: SymInfo a -> Bool
$cnull :: forall a. SymInfo a -> Bool
toList :: SymInfo a -> [a]
$ctoList :: forall a. SymInfo a -> [a]
foldl1 :: (a -> a -> a) -> SymInfo a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SymInfo a -> a
foldr1 :: (a -> a -> a) -> SymInfo a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> SymInfo a -> a
foldl' :: (b -> a -> b) -> b -> SymInfo a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SymInfo a -> b
foldl :: (b -> a -> b) -> b -> SymInfo a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SymInfo a -> b
foldr' :: (a -> b -> b) -> b -> SymInfo a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SymInfo a -> b
foldr :: (a -> b -> b) -> b -> SymInfo a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> SymInfo a -> b
foldMap' :: (a -> m) -> SymInfo a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SymInfo a -> m
foldMap :: (a -> m) -> SymInfo a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SymInfo a -> m
fold :: SymInfo m -> m
$cfold :: forall m. Monoid m => SymInfo m -> m
Foldable, Functor SymInfo
Foldable SymInfo
Functor SymInfo
-> Foldable SymInfo
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SymInfo a -> f (SymInfo b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SymInfo (f a) -> f (SymInfo a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SymInfo a -> m (SymInfo b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SymInfo (m a) -> m (SymInfo a))
-> Traversable SymInfo
(a -> f b) -> SymInfo a -> f (SymInfo 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 => SymInfo (m a) -> m (SymInfo a)
forall (f :: * -> *) a.
Applicative f =>
SymInfo (f a) -> f (SymInfo a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SymInfo a -> m (SymInfo b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SymInfo a -> f (SymInfo b)
sequence :: SymInfo (m a) -> m (SymInfo a)
$csequence :: forall (m :: * -> *) a. Monad m => SymInfo (m a) -> m (SymInfo a)
mapM :: (a -> m b) -> SymInfo a -> m (SymInfo b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SymInfo a -> m (SymInfo b)
sequenceA :: SymInfo (f a) -> f (SymInfo a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
SymInfo (f a) -> f (SymInfo a)
traverse :: (a -> f b) -> SymInfo a -> f (SymInfo b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SymInfo a -> f (SymInfo b)
$cp2Traversable :: Foldable SymInfo
$cp1Traversable :: Functor SymInfo
Traversable)


{- | The type definition associated with a type constructor.
A definition for `data MyList a = Cons a (MyList a) | Nil` looks like:
@
  TypeDef { targs = [a]
          , [ ("Cons", VariantUnnamed [TVar a, TCon ("MyList" [TVar a])])
            , ("Nil", VariantUnnamed [])
            ]
          }
@
(Data constructors for identifiers are omitted for brevity.)
Note that for a flat type system, where all type constructors are nullary, targs
will just be set to [].
-}
data TypeDef = TypeDef
  { TypeDef -> [(DConId, TypeVariant)]
variants :: [(DConId, TypeVariant)]
  , TypeDef -> [TVarId]
targs :: [TVarId]
  }
  deriving (Int -> TypeDef -> ShowS
[TypeDef] -> ShowS
TypeDef -> String
(Int -> TypeDef -> ShowS)
-> (TypeDef -> String) -> ([TypeDef] -> ShowS) -> Show TypeDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeDef] -> ShowS
$cshowList :: [TypeDef] -> ShowS
show :: TypeDef -> String
$cshow :: TypeDef -> String
showsPrec :: Int -> TypeDef -> ShowS
$cshowsPrec :: Int -> TypeDef -> ShowS
Show, TypeDef -> TypeDef -> Bool
(TypeDef -> TypeDef -> Bool)
-> (TypeDef -> TypeDef -> Bool) -> Eq TypeDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeDef -> TypeDef -> Bool
$c/= :: TypeDef -> TypeDef -> Bool
== :: TypeDef -> TypeDef -> Bool
$c== :: TypeDef -> TypeDef -> Bool
Eq, Typeable, Typeable TypeDef
DataType
Constr
Typeable TypeDef
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeDef -> c TypeDef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeDef)
-> (TypeDef -> Constr)
-> (TypeDef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeDef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDef))
-> ((forall b. Data b => b -> b) -> TypeDef -> TypeDef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeDef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeDef -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeDef -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeDef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeDef -> m TypeDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeDef -> m TypeDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeDef -> m TypeDef)
-> Data TypeDef
TypeDef -> DataType
TypeDef -> Constr
(forall b. Data b => b -> b) -> TypeDef -> TypeDef
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDef -> c TypeDef
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDef
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) -> TypeDef -> u
forall u. (forall d. Data d => d -> u) -> TypeDef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDef -> c TypeDef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDef)
$cTypeDef :: Constr
$tTypeDef :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
gmapMp :: (forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
gmapM :: (forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDef -> m TypeDef
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeDef -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeDef -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeDef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeDef -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDef -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDef -> r
gmapT :: (forall b. Data b => b -> b) -> TypeDef -> TypeDef
$cgmapT :: (forall b. Data b => b -> b) -> TypeDef -> TypeDef
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDef)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeDef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDef)
dataTypeOf :: TypeDef -> DataType
$cdataTypeOf :: TypeDef -> DataType
toConstr :: TypeDef -> Constr
$ctoConstr :: TypeDef -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDef
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDef -> c TypeDef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDef -> c TypeDef
$cp1Data :: Typeable TypeDef
Data)


-- | Arguments to a data constructor, whose fields may or may not be named
data TypeVariant
  = -- | A record with named fields
    VariantNamed [(VarId, Type)]
  | -- | An algebraic type with unnamed fields
    VariantUnnamed [Type]
  deriving (Int -> TypeVariant -> ShowS
[TypeVariant] -> ShowS
TypeVariant -> String
(Int -> TypeVariant -> ShowS)
-> (TypeVariant -> String)
-> ([TypeVariant] -> ShowS)
-> Show TypeVariant
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeVariant] -> ShowS
$cshowList :: [TypeVariant] -> ShowS
show :: TypeVariant -> String
$cshow :: TypeVariant -> String
showsPrec :: Int -> TypeVariant -> ShowS
$cshowsPrec :: Int -> TypeVariant -> ShowS
Show, TypeVariant -> TypeVariant -> Bool
(TypeVariant -> TypeVariant -> Bool)
-> (TypeVariant -> TypeVariant -> Bool) -> Eq TypeVariant
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeVariant -> TypeVariant -> Bool
$c/= :: TypeVariant -> TypeVariant -> Bool
== :: TypeVariant -> TypeVariant -> Bool
$c== :: TypeVariant -> TypeVariant -> Bool
Eq, Typeable, Typeable TypeVariant
DataType
Constr
Typeable TypeVariant
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeVariant -> c TypeVariant)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeVariant)
-> (TypeVariant -> Constr)
-> (TypeVariant -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeVariant))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeVariant))
-> ((forall b. Data b => b -> b) -> TypeVariant -> TypeVariant)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeVariant -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeVariant -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeVariant -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeVariant -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant)
-> Data TypeVariant
TypeVariant -> DataType
TypeVariant -> Constr
(forall b. Data b => b -> b) -> TypeVariant -> TypeVariant
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeVariant -> c TypeVariant
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeVariant
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) -> TypeVariant -> u
forall u. (forall d. Data d => d -> u) -> TypeVariant -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeVariant -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeVariant -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeVariant
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeVariant -> c TypeVariant
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeVariant)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeVariant)
$cVariantUnnamed :: Constr
$cVariantNamed :: Constr
$tTypeVariant :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
gmapMp :: (forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
gmapM :: (forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeVariant -> m TypeVariant
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeVariant -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeVariant -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeVariant -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeVariant -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeVariant -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeVariant -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeVariant -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeVariant -> r
gmapT :: (forall b. Data b => b -> b) -> TypeVariant -> TypeVariant
$cgmapT :: (forall b. Data b => b -> b) -> TypeVariant -> TypeVariant
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeVariant)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeVariant)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeVariant)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeVariant)
dataTypeOf :: TypeVariant -> DataType
$cdataTypeOf :: TypeVariant -> DataType
toConstr :: TypeVariant -> Constr
$ctoConstr :: TypeVariant -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeVariant
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeVariant
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeVariant -> c TypeVariant
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeVariant -> c TypeVariant
$cp1Data :: Typeable TypeVariant
Data)


-- | A name to be bound; 'Nothing' represents a wildcard, e.g., @let _ = ...@.
data Binder t = Binder {Binder t -> Maybe VarId
_binderId :: Maybe VarId, Binder t -> t
_binderType :: t}
  deriving (Int -> Binder t -> ShowS
[Binder t] -> ShowS
Binder t -> String
(Int -> Binder t -> ShowS)
-> (Binder t -> String) -> ([Binder t] -> ShowS) -> Show (Binder t)
forall t. Show t => Int -> Binder t -> ShowS
forall t. Show t => [Binder t] -> ShowS
forall t. Show t => Binder t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Binder t] -> ShowS
$cshowList :: forall t. Show t => [Binder t] -> ShowS
show :: Binder t -> String
$cshow :: forall t. Show t => Binder t -> String
showsPrec :: Int -> Binder t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Binder t -> ShowS
Show, Binder t -> Binder t -> Bool
(Binder t -> Binder t -> Bool)
-> (Binder t -> Binder t -> Bool) -> Eq (Binder t)
forall t. Eq t => Binder t -> Binder t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Binder t -> Binder t -> Bool
$c/= :: forall t. Eq t => Binder t -> Binder t -> Bool
== :: Binder t -> Binder t -> Bool
$c== :: forall t. Eq t => Binder t -> Binder t -> Bool
Eq, Typeable, Typeable (Binder t)
DataType
Constr
Typeable (Binder t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binder t -> c (Binder t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binder t))
-> (Binder t -> Constr)
-> (Binder t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binder t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Binder t)))
-> ((forall b. Data b => b -> b) -> Binder t -> Binder t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binder t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binder t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Binder t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Binder t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binder t -> m (Binder t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binder t -> m (Binder t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binder t -> m (Binder t))
-> Data (Binder t)
Binder t -> DataType
Binder t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Binder t))
(forall b. Data b => b -> b) -> Binder t -> Binder t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder t -> c (Binder t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder t)
forall t. Data t => Typeable (Binder t)
forall t. Data t => Binder t -> DataType
forall t. Data t => Binder t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Binder t -> Binder t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Binder t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> Binder t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder t -> c (Binder t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder t))
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) -> Binder t -> u
forall u. (forall d. Data d => d -> u) -> Binder t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder t -> c (Binder t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder t))
$cBinder :: Constr
$tBinder :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
gmapMp :: (forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
gmapM :: (forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Binder t -> m (Binder t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Binder t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Binder t -> u
gmapQ :: (forall d. Data d => d -> u) -> Binder t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> Binder t -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binder t -> r
gmapT :: (forall b. Data b => b -> b) -> Binder t -> Binder t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Binder t -> Binder t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binder t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Binder t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binder t))
dataTypeOf :: Binder t -> DataType
$cdataTypeOf :: forall t. Data t => Binder t -> DataType
toConstr :: Binder t -> Constr
$ctoConstr :: forall t. Data t => Binder t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binder t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder t -> c (Binder t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binder t -> c (Binder t)
$cp1Data :: forall t. Data t => Typeable (Binder t)
Data, a -> Binder b -> Binder a
(a -> b) -> Binder a -> Binder b
(forall a b. (a -> b) -> Binder a -> Binder b)
-> (forall a b. a -> Binder b -> Binder a) -> Functor Binder
forall a b. a -> Binder b -> Binder a
forall a b. (a -> b) -> Binder a -> Binder b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Binder b -> Binder a
$c<$ :: forall a b. a -> Binder b -> Binder a
fmap :: (a -> b) -> Binder a -> Binder b
$cfmap :: forall a b. (a -> b) -> Binder a -> Binder b
Functor, Binder a -> Bool
(a -> m) -> Binder a -> m
(a -> b -> b) -> b -> Binder a -> b
(forall m. Monoid m => Binder m -> m)
-> (forall m a. Monoid m => (a -> m) -> Binder a -> m)
-> (forall m a. Monoid m => (a -> m) -> Binder a -> m)
-> (forall a b. (a -> b -> b) -> b -> Binder a -> b)
-> (forall a b. (a -> b -> b) -> b -> Binder a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binder a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binder a -> b)
-> (forall a. (a -> a -> a) -> Binder a -> a)
-> (forall a. (a -> a -> a) -> Binder a -> a)
-> (forall a. Binder a -> [a])
-> (forall a. Binder a -> Bool)
-> (forall a. Binder a -> Int)
-> (forall a. Eq a => a -> Binder a -> Bool)
-> (forall a. Ord a => Binder a -> a)
-> (forall a. Ord a => Binder a -> a)
-> (forall a. Num a => Binder a -> a)
-> (forall a. Num a => Binder a -> a)
-> Foldable Binder
forall a. Eq a => a -> Binder a -> Bool
forall a. Num a => Binder a -> a
forall a. Ord a => Binder a -> a
forall m. Monoid m => Binder m -> m
forall a. Binder a -> Bool
forall a. Binder a -> Int
forall a. Binder a -> [a]
forall a. (a -> a -> a) -> Binder a -> a
forall m a. Monoid m => (a -> m) -> Binder a -> m
forall b a. (b -> a -> b) -> b -> Binder a -> b
forall a b. (a -> b -> b) -> b -> Binder 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 :: Binder a -> a
$cproduct :: forall a. Num a => Binder a -> a
sum :: Binder a -> a
$csum :: forall a. Num a => Binder a -> a
minimum :: Binder a -> a
$cminimum :: forall a. Ord a => Binder a -> a
maximum :: Binder a -> a
$cmaximum :: forall a. Ord a => Binder a -> a
elem :: a -> Binder a -> Bool
$celem :: forall a. Eq a => a -> Binder a -> Bool
length :: Binder a -> Int
$clength :: forall a. Binder a -> Int
null :: Binder a -> Bool
$cnull :: forall a. Binder a -> Bool
toList :: Binder a -> [a]
$ctoList :: forall a. Binder a -> [a]
foldl1 :: (a -> a -> a) -> Binder a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Binder a -> a
foldr1 :: (a -> a -> a) -> Binder a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Binder a -> a
foldl' :: (b -> a -> b) -> b -> Binder a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Binder a -> b
foldl :: (b -> a -> b) -> b -> Binder a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Binder a -> b
foldr' :: (a -> b -> b) -> b -> Binder a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Binder a -> b
foldr :: (a -> b -> b) -> b -> Binder a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Binder a -> b
foldMap' :: (a -> m) -> Binder a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binder a -> m
foldMap :: (a -> m) -> Binder a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Binder a -> m
fold :: Binder m -> m
$cfold :: forall m. Monoid m => Binder m -> m
Foldable, Functor Binder
Foldable Binder
Functor Binder
-> Foldable Binder
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Binder a -> f (Binder b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Binder (f a) -> f (Binder a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Binder a -> m (Binder b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Binder (m a) -> m (Binder a))
-> Traversable Binder
(a -> f b) -> Binder a -> f (Binder 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 => Binder (m a) -> m (Binder a)
forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
sequence :: Binder (m a) -> m (Binder a)
$csequence :: forall (m :: * -> *) a. Monad m => Binder (m a) -> m (Binder a)
mapM :: (a -> m b) -> Binder a -> m (Binder b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
sequenceA :: Binder (f a) -> f (Binder a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
traverse :: (a -> f b) -> Binder a -> f (Binder b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
$cp2Traversable :: Foldable Binder
$cp1Traversable :: Functor Binder
Traversable)


-- | An anonymous (wildcard) binder.
pattern BindAnon :: t -> Binder t
pattern $bBindAnon :: t -> Binder t
$mBindAnon :: forall r t. Binder t -> (t -> r) -> (Void# -> r) -> r
BindAnon t = Binder{_binderId = Nothing, _binderType = t}


-- | A concrete, named binder.
pattern BindVar :: VarId -> t -> Binder t
pattern $bBindVar :: VarId -> t -> Binder t
$mBindVar :: forall r t. Binder t -> (VarId -> t -> r) -> (Void# -> r) -> r
BindVar v t = Binder{_binderId = Just v, _binderType = t}


{-# COMPLETE BindAnon, BindVar #-}


{- | Literal values supported by the language.

Note that these don't carry any connotation of type: @1@ just means @1@,
-}
data Literal
  = LitIntegral Integer
  | LitEvent
  deriving (Literal -> Literal -> Bool
(Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool) -> Eq Literal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c== :: Literal -> Literal -> Bool
Eq, Int -> Literal -> ShowS
[Literal] -> ShowS
Literal -> String
(Int -> Literal -> ShowS)
-> (Literal -> String) -> ([Literal] -> ShowS) -> Show Literal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Literal] -> ShowS
$cshowList :: [Literal] -> ShowS
show :: Literal -> String
$cshow :: Literal -> String
showsPrec :: Int -> Literal -> ShowS
$cshowsPrec :: Int -> Literal -> ShowS
Show, Typeable, Typeable Literal
DataType
Constr
Typeable Literal
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal -> c Literal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal)
-> (Literal -> Constr)
-> (Literal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal))
-> ((forall b. Data b => b -> b) -> Literal -> Literal)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall u. (forall d. Data d => d -> u) -> Literal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> Data Literal
Literal -> DataType
Literal -> Constr
(forall b. Data b => b -> b) -> Literal -> Literal
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
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) -> Literal -> u
forall u. (forall d. Data d => d -> u) -> Literal -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cLitEvent :: Constr
$cLitIntegral :: Constr
$tLiteral :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapMp :: (forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapM :: (forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
gmapQ :: (forall d. Data d => d -> u) -> Literal -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
$cgmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Literal)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
dataTypeOf :: Literal -> DataType
$cdataTypeOf :: Literal -> DataType
toConstr :: Literal -> Constr
$ctoConstr :: Literal -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
$cp1Data :: Typeable Literal
Data)


{- | Primitive operations.

These should be the kinds of functions one may expect to be available as
operators in C, or as instructions in an assembly language.

For simplicity and consistency, they should be:

- Pure (i.e., side-effectful iff operands are side-effectful, i.e., no @=@)
- Strict in all operands (i.e., no @&&@ or @||@)

We can instead implement short-circuit control flow using match statements.
-}
data PrimOp
  = -- | negation, i.e., -x
    PrimNeg
  | -- | logical not, i.e., !x
    PrimNot
  | -- | bitwise not, i.e., ~x
    PrimBitNot
  | -- | addition, i.e., x + y
    PrimAdd
  | -- | subtraction, i.e., x - y
    PrimSub
  | -- | multiplication, i.e., x * y
    PrimMul
  | -- | division, i.e., x / y
    PrimDiv
  | -- | modulus, i.e., x % y
    PrimMod
  | -- | bitwise-and, i.e., x & y
    PrimBitAnd
  | -- | bitwise-or, i.e., x | y
    PrimBitOr
  | -- | equality, i.e., x == y
    PrimEq
  | -- | equality, i.e., x != y
    PrimNeq
  | -- | greater than, i.e., x > y
    PrimGt
  | -- | greater than or equal to, i.e., x >= y
    PrimGe
  | -- | less than, i.e., x < y
    PrimLt
  | -- | less than or equal to, i.e., x <= y
    PrimLe
  deriving (PrimOp -> PrimOp -> Bool
(PrimOp -> PrimOp -> Bool)
-> (PrimOp -> PrimOp -> Bool) -> Eq PrimOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrimOp -> PrimOp -> Bool
$c/= :: PrimOp -> PrimOp -> Bool
== :: PrimOp -> PrimOp -> Bool
$c== :: PrimOp -> PrimOp -> Bool
Eq, Int -> PrimOp -> ShowS
[PrimOp] -> ShowS
PrimOp -> String
(Int -> PrimOp -> ShowS)
-> (PrimOp -> String) -> ([PrimOp] -> ShowS) -> Show PrimOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrimOp] -> ShowS
$cshowList :: [PrimOp] -> ShowS
show :: PrimOp -> String
$cshow :: PrimOp -> String
showsPrec :: Int -> PrimOp -> ShowS
$cshowsPrec :: Int -> PrimOp -> ShowS
Show, Typeable, Typeable PrimOp
DataType
Constr
Typeable PrimOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PrimOp -> c PrimOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrimOp)
-> (PrimOp -> Constr)
-> (PrimOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrimOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimOp))
-> ((forall b. Data b => b -> b) -> PrimOp -> PrimOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> PrimOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PrimOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrimOp -> m PrimOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrimOp -> m PrimOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrimOp -> m PrimOp)
-> Data PrimOp
PrimOp -> DataType
PrimOp -> Constr
(forall b. Data b => b -> b) -> PrimOp -> PrimOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimOp -> c PrimOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimOp
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) -> PrimOp -> u
forall u. (forall d. Data d => d -> u) -> PrimOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimOp -> c PrimOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimOp)
$cPrimLe :: Constr
$cPrimLt :: Constr
$cPrimGe :: Constr
$cPrimGt :: Constr
$cPrimNeq :: Constr
$cPrimEq :: Constr
$cPrimBitOr :: Constr
$cPrimBitAnd :: Constr
$cPrimMod :: Constr
$cPrimDiv :: Constr
$cPrimMul :: Constr
$cPrimSub :: Constr
$cPrimAdd :: Constr
$cPrimBitNot :: Constr
$cPrimNot :: Constr
$cPrimNeg :: Constr
$tPrimOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
gmapMp :: (forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
gmapM :: (forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimOp -> m PrimOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrimOp -> u
gmapQ :: (forall d. Data d => d -> u) -> PrimOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrimOp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimOp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimOp -> r
gmapT :: (forall b. Data b => b -> b) -> PrimOp -> PrimOp
$cgmapT :: (forall b. Data b => b -> b) -> PrimOp -> PrimOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrimOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimOp)
dataTypeOf :: PrimOp -> DataType
$cdataTypeOf :: PrimOp -> DataType
toConstr :: PrimOp -> Constr
$ctoConstr :: PrimOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimOp -> c PrimOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimOp -> c PrimOp
$cp1Data :: Typeable PrimOp
Data)


-- | Primitive functions for side-effects and imperative control flow.
data Primitive
  = -- | @New e@ allocates a schedule variable initialized to @e@, and
    --  returns a reference to it.
    New
  | -- | @Dup r@ dups the reference @r@ and returns @r@.
    Dup
  | -- | @Drop e r@ evaluates to @e@, but also drops @r@.
    Drop
  | -- | @Deref r@ dereferences reference @r@ to obtain its value.
    Deref
  | -- | @Assign r e@ instantly assigns value @e@ to reference @r@.
    Assign
  | -- | @After t r e@ assigns @e@ to reference @r@ after time @t@.
    After
  | -- | @Par  es+@ evaluates expressions @es@ concurrently.
    Par
  | -- | @Wait rs+@ waits for an assignment to any reference in @rs@.
    Wait
  | -- | @Loop b@ loops body @b@ forever.
    Loop
  | -- | @Break@ breaks out of the innermost loop.
    Break
  | -- | @Now@ obtains the value of the current instant
    Now
  | -- | @Last@ obtains the time a value was last assigned
    Last
  | -- | Inlined C expression code.
    PrimOp PrimOp
  | -- | Primitive operator.
    CQuote String
  | -- | Direct call to arbitrary C function (NOTE: HACKY).
    CCall CSym
  | -- | Call to well-typed extern symbol.
    FfiCall VarId
  deriving (Primitive -> Primitive -> Bool
(Primitive -> Primitive -> Bool)
-> (Primitive -> Primitive -> Bool) -> Eq Primitive
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Primitive -> Primitive -> Bool
$c/= :: Primitive -> Primitive -> Bool
== :: Primitive -> Primitive -> Bool
$c== :: Primitive -> Primitive -> Bool
Eq, Int -> Primitive -> ShowS
[Primitive] -> ShowS
Primitive -> String
(Int -> Primitive -> ShowS)
-> (Primitive -> String)
-> ([Primitive] -> ShowS)
-> Show Primitive
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Primitive] -> ShowS
$cshowList :: [Primitive] -> ShowS
show :: Primitive -> String
$cshow :: Primitive -> String
showsPrec :: Int -> Primitive -> ShowS
$cshowsPrec :: Int -> Primitive -> ShowS
Show, Typeable, Typeable Primitive
DataType
Constr
Typeable Primitive
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Primitive -> c Primitive)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Primitive)
-> (Primitive -> Constr)
-> (Primitive -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Primitive))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Primitive))
-> ((forall b. Data b => b -> b) -> Primitive -> Primitive)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Primitive -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Primitive -> r)
-> (forall u. (forall d. Data d => d -> u) -> Primitive -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Primitive -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Primitive -> m Primitive)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Primitive -> m Primitive)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Primitive -> m Primitive)
-> Data Primitive
Primitive -> DataType
Primitive -> Constr
(forall b. Data b => b -> b) -> Primitive -> Primitive
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Primitive -> c Primitive
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Primitive
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) -> Primitive -> u
forall u. (forall d. Data d => d -> u) -> Primitive -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Primitive -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Primitive -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Primitive -> m Primitive
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Primitive -> m Primitive
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Primitive
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Primitive -> c Primitive
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Primitive)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Primitive)
$cFfiCall :: Constr
$cCCall :: Constr
$cCQuote :: Constr
$cPrimOp :: Constr
$cLast :: Constr
$cNow :: Constr
$cBreak :: Constr
$cLoop :: Constr
$cWait :: Constr
$cPar :: Constr
$cAfter :: Constr
$cAssign :: Constr
$cDeref :: Constr
$cDrop :: Constr
$cDup :: Constr
$cNew :: Constr
$tPrimitive :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Primitive -> m Primitive
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Primitive -> m Primitive
gmapMp :: (forall d. Data d => d -> m d) -> Primitive -> m Primitive
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Primitive -> m Primitive
gmapM :: (forall d. Data d => d -> m d) -> Primitive -> m Primitive
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Primitive -> m Primitive
gmapQi :: Int -> (forall d. Data d => d -> u) -> Primitive -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Primitive -> u
gmapQ :: (forall d. Data d => d -> u) -> Primitive -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Primitive -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Primitive -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Primitive -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Primitive -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Primitive -> r
gmapT :: (forall b. Data b => b -> b) -> Primitive -> Primitive
$cgmapT :: (forall b. Data b => b -> b) -> Primitive -> Primitive
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Primitive)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Primitive)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Primitive)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Primitive)
dataTypeOf :: Primitive -> DataType
$cdataTypeOf :: Primitive -> DataType
toConstr :: Primitive -> Constr
$ctoConstr :: Primitive -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Primitive
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Primitive
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Primitive -> c Primitive
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Primitive -> c Primitive
$cp1Data :: Typeable Primitive
Data)


{- | Expressions, based on the let-polymorphic lambda calculus.

@t@ represents the type of this expression, e.g., 'IR.Types.Flat'. At
various stages, this may represent a richer or simpler type
system. The type is embedded in each data constructor so as to
type-annotate the entire expression tree.

Designed for side effects with call-by-value evaluation order. Basic
sequencing can be recovered through let-bindings:

> let _ = stmt1 in
> let _ = stmt2 in
> ...

Effects of @stmt1@ take place before that of @stmt2@.
-}
data Expr t
  = -- | @Var n t@ is a variable named @n@ of type @t@.
    Var VarId t
  | -- | @Data d t@ is a data constructor named @d@ of type @t@.
    Data DConId t
  | -- | @Lit l t@ is a literal value @l@ of type @t@.
    Lit Literal t
  | -- | @App f a t@ applies function @f@ to argument @a@, producing a value of
    --  type @t@.
    App (Expr t) (Expr t) t
  | -- | @Let [(n, v)] b t@ binds value @v@ to variable @v@ in its body @b@.
    --
    --  The bindings list may only be of length greater than 1 for a set of mutually
    --  co-recursive functions.
    Let [(Binder t, Expr t)] (Expr t) t
  | -- | @Lambda v b t@ constructs an anonymous function of type @t@ that binds
    --  a value to parameter @v@ in its body @b@.
    Lambda (Binder t) (Expr t) t
  | -- | @Match s alts t@ pattern-matches on scrutinee @s@ against alternatives
    --  @alts@, each producing a value of type @t@.
    Match (Expr t) [(Alt t, Expr t)] t
  | -- | @Prim p es t@ applies primitive @p@ arguments @es@, producing a value
    --  of type @t@.
    Prim Primitive [Expr t] t
  | -- | @Exception et t@ produces a exception for the program.
    Exception ExceptType t
  deriving (Expr t -> Expr t -> Bool
(Expr t -> Expr t -> Bool)
-> (Expr t -> Expr t -> Bool) -> Eq (Expr t)
forall t. Eq t => Expr t -> Expr t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expr t -> Expr t -> Bool
$c/= :: forall t. Eq t => Expr t -> Expr t -> Bool
== :: Expr t -> Expr t -> Bool
$c== :: forall t. Eq t => Expr t -> Expr t -> Bool
Eq, Int -> Expr t -> ShowS
[Expr t] -> ShowS
Expr t -> String
(Int -> Expr t -> ShowS)
-> (Expr t -> String) -> ([Expr t] -> ShowS) -> Show (Expr t)
forall t. Show t => Int -> Expr t -> ShowS
forall t. Show t => [Expr t] -> ShowS
forall t. Show t => Expr t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expr t] -> ShowS
$cshowList :: forall t. Show t => [Expr t] -> ShowS
show :: Expr t -> String
$cshow :: forall t. Show t => Expr t -> String
showsPrec :: Int -> Expr t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Expr t -> ShowS
Show, Typeable, Typeable (Expr t)
DataType
Constr
Typeable (Expr t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr t -> c (Expr t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr t))
-> (Expr t -> Constr)
-> (Expr t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t)))
-> ((forall b. Data b => b -> b) -> Expr t -> Expr t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Expr t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Expr t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
-> Data (Expr t)
Expr t -> DataType
Expr t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
(forall b. Data b => b -> b) -> Expr t -> Expr t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall t. Data t => Typeable (Expr t)
forall t. Data t => Expr t -> DataType
forall t. Data t => Expr t -> Constr
forall t.
Data t =>
(forall b. Data b => b -> b) -> Expr t -> Expr t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Expr t -> u
forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
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) -> Expr t -> u
forall u. (forall d. Data d => d -> u) -> Expr t -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
$cException :: Constr
$cPrim :: Constr
$cMatch :: Constr
$cLambda :: Constr
$cLet :: Constr
$cApp :: Constr
$cLit :: Constr
$cData :: Constr
$cVar :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapMp :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapM :: (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Expr t -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr t -> [u]
$cgmapQ :: forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
gmapT :: (forall b. Data b => b -> b) -> Expr t -> Expr t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> Expr t -> Expr t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Expr t))
dataTypeOf :: Expr t -> DataType
$cdataTypeOf :: forall t. Data t => Expr t -> DataType
toConstr :: Expr t -> Constr
$ctoConstr :: forall t. Data t => Expr t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Expr t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr t -> c (Expr t)
$cp1Data :: forall t. Data t => Typeable (Expr t)
Data, a -> Expr b -> Expr a
(a -> b) -> Expr a -> Expr b
(forall a b. (a -> b) -> Expr a -> Expr b)
-> (forall a b. a -> Expr b -> Expr a) -> Functor Expr
forall a b. a -> Expr b -> Expr a
forall a b. (a -> b) -> Expr a -> Expr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Expr b -> Expr a
$c<$ :: forall a b. a -> Expr b -> Expr a
fmap :: (a -> b) -> Expr a -> Expr b
$cfmap :: forall a b. (a -> b) -> Expr a -> Expr b
Functor, Expr a -> Bool
(a -> m) -> Expr a -> m
(a -> b -> b) -> b -> Expr a -> b
(forall m. Monoid m => Expr m -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
-> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
-> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
-> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
-> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
-> (forall a. (a -> a -> a) -> Expr a -> a)
-> (forall a. (a -> a -> a) -> Expr a -> a)
-> (forall a. Expr a -> [a])
-> (forall a. Expr a -> Bool)
-> (forall a. Expr a -> Int)
-> (forall a. Eq a => a -> Expr a -> Bool)
-> (forall a. Ord a => Expr a -> a)
-> (forall a. Ord a => Expr a -> a)
-> (forall a. Num a => Expr a -> a)
-> (forall a. Num a => Expr a -> a)
-> Foldable Expr
forall a. Eq a => a -> Expr a -> Bool
forall a. Num a => Expr a -> a
forall a. Ord a => Expr a -> a
forall m. Monoid m => Expr m -> m
forall a. Expr a -> Bool
forall a. Expr a -> Int
forall a. Expr a -> [a]
forall a. (a -> a -> a) -> Expr a -> a
forall m a. Monoid m => (a -> m) -> Expr a -> m
forall b a. (b -> a -> b) -> b -> Expr a -> b
forall a b. (a -> b -> b) -> b -> Expr 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 :: Expr a -> a
$cproduct :: forall a. Num a => Expr a -> a
sum :: Expr a -> a
$csum :: forall a. Num a => Expr a -> a
minimum :: Expr a -> a
$cminimum :: forall a. Ord a => Expr a -> a
maximum :: Expr a -> a
$cmaximum :: forall a. Ord a => Expr a -> a
elem :: a -> Expr a -> Bool
$celem :: forall a. Eq a => a -> Expr a -> Bool
length :: Expr a -> Int
$clength :: forall a. Expr a -> Int
null :: Expr a -> Bool
$cnull :: forall a. Expr a -> Bool
toList :: Expr a -> [a]
$ctoList :: forall a. Expr a -> [a]
foldl1 :: (a -> a -> a) -> Expr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Expr a -> a
foldr1 :: (a -> a -> a) -> Expr a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Expr a -> a
foldl' :: (b -> a -> b) -> b -> Expr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldl :: (b -> a -> b) -> b -> Expr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldr' :: (a -> b -> b) -> b -> Expr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldr :: (a -> b -> b) -> b -> Expr a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldMap' :: (a -> m) -> Expr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
foldMap :: (a -> m) -> Expr a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
fold :: Expr m -> m
$cfold :: forall m. Monoid m => Expr m -> m
Foldable, Functor Expr
Foldable Expr
Functor Expr
-> Foldable Expr
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Expr a -> f (Expr b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Expr (f a) -> f (Expr a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Expr a -> m (Expr b))
-> (forall (m :: * -> *) a. Monad m => Expr (m a) -> m (Expr a))
-> Traversable Expr
(a -> f b) -> Expr a -> f (Expr 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 => Expr (m a) -> m (Expr a)
forall (f :: * -> *) a. Applicative f => Expr (f a) -> f (Expr a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr a -> m (Expr b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr a -> f (Expr b)
sequence :: Expr (m a) -> m (Expr a)
$csequence :: forall (m :: * -> *) a. Monad m => Expr (m a) -> m (Expr a)
mapM :: (a -> m b) -> Expr a -> m (Expr b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr a -> m (Expr b)
sequenceA :: Expr (f a) -> f (Expr a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Expr (f a) -> f (Expr a)
traverse :: (a -> f b) -> Expr a -> f (Expr b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr a -> f (Expr b)
$cp2Traversable :: Foldable Expr
$cp1Traversable :: Functor Expr
Traversable)


-- | An alternative in a pattern-match.
data Alt t
  = -- | @AltData d vs@ matches data constructor @d@, and recursive patterns @alts@.
    AltData DConId [Alt t] t
  | -- | @AltLit l@ matches against literal @l@, producing expression @e@.
    AltLit Literal t
  | -- | @AltBinder v@ matches anything, and bound to name @v@.
    AltBinder (Binder t)
  deriving (Alt t -> Alt t -> Bool
(Alt t -> Alt t -> Bool) -> (Alt t -> Alt t -> Bool) -> Eq (Alt t)
forall t. Eq t => Alt t -> Alt t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Alt t -> Alt t -> Bool
$c/= :: forall t. Eq t => Alt t -> Alt t -> Bool
== :: Alt t -> Alt t -> Bool
$c== :: forall t. Eq t => Alt t -> Alt t -> Bool
Eq, Int -> Alt t -> ShowS
[Alt t] -> ShowS
Alt t -> String
(Int -> Alt t -> ShowS)
-> (Alt t -> String) -> ([Alt t] -> ShowS) -> Show (Alt t)
forall t. Show t => Int -> Alt t -> ShowS
forall t. Show t => [Alt t] -> ShowS
forall t. Show t => Alt t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Alt t] -> ShowS
$cshowList :: forall t. Show t => [Alt t] -> ShowS
show :: Alt t -> String
$cshow :: forall t. Show t => Alt t -> String
showsPrec :: Int -> Alt t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> Alt t -> ShowS
Show, Typeable, Typeable (Alt t)
DataType
Constr
Typeable (Alt t)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alt t -> c (Alt t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Alt t))
-> (Alt t -> Constr)
-> (Alt t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Alt t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt t)))
-> ((forall b. Data b => b -> b) -> Alt t -> Alt t)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r)
-> (forall u. (forall d. Data d => d -> u) -> Alt t -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Alt t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alt t -> m (Alt t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt t -> m (Alt t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt t -> m (Alt t))
-> Data (Alt t)
Alt t -> DataType
Alt t -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Alt t))
(forall b. Data b => b -> b) -> Alt t -> Alt t
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt t -> c (Alt t)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt t)
forall t. Data t => Typeable (Alt t)
forall t. Data t => Alt t -> DataType
forall t. Data t => Alt t -> Constr
forall t. Data t => (forall b. Data b => b -> b) -> Alt t -> Alt t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Alt t -> u
forall t u. Data t => (forall d. Data d => d -> u) -> Alt t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt t -> c (Alt t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt t))
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) -> Alt t -> u
forall u. (forall d. Data d => d -> u) -> Alt t -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt t -> c (Alt t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt t))
$cAltBinder :: Constr
$cAltLit :: Constr
$cAltData :: Constr
$tAlt :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
gmapMp :: (forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
gmapM :: (forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> Alt t -> m (Alt t)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> Alt t -> u
gmapQ :: (forall d. Data d => d -> u) -> Alt t -> [u]
$cgmapQ :: forall t u. Data t => (forall d. Data d => d -> u) -> Alt t -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt t -> r
gmapT :: (forall b. Data b => b -> b) -> Alt t -> Alt t
$cgmapT :: forall t. Data t => (forall b. Data b => b -> b) -> Alt t -> Alt t
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt t))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Alt t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Alt t))
dataTypeOf :: Alt t -> DataType
$cdataTypeOf :: forall t. Data t => Alt t -> DataType
toConstr :: Alt t -> Constr
$ctoConstr :: forall t. Data t => Alt t -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Alt t)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt t -> c (Alt t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alt t -> c (Alt t)
$cp1Data :: forall t. Data t => Typeable (Alt t)
Data, a -> Alt b -> Alt a
(a -> b) -> Alt a -> Alt b
(forall a b. (a -> b) -> Alt a -> Alt b)
-> (forall a b. a -> Alt b -> Alt a) -> Functor Alt
forall a b. a -> Alt b -> Alt a
forall a b. (a -> b) -> Alt a -> Alt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Alt b -> Alt a
$c<$ :: forall a b. a -> Alt b -> Alt a
fmap :: (a -> b) -> Alt a -> Alt b
$cfmap :: forall a b. (a -> b) -> Alt a -> Alt b
Functor, Alt a -> Bool
(a -> m) -> Alt a -> m
(a -> b -> b) -> b -> Alt a -> b
(forall m. Monoid m => Alt m -> m)
-> (forall m a. Monoid m => (a -> m) -> Alt a -> m)
-> (forall m a. Monoid m => (a -> m) -> Alt a -> m)
-> (forall a b. (a -> b -> b) -> b -> Alt a -> b)
-> (forall a b. (a -> b -> b) -> b -> Alt a -> b)
-> (forall b a. (b -> a -> b) -> b -> Alt a -> b)
-> (forall b a. (b -> a -> b) -> b -> Alt a -> b)
-> (forall a. (a -> a -> a) -> Alt a -> a)
-> (forall a. (a -> a -> a) -> Alt a -> a)
-> (forall a. Alt a -> [a])
-> (forall a. Alt a -> Bool)
-> (forall a. Alt a -> Int)
-> (forall a. Eq a => a -> Alt a -> Bool)
-> (forall a. Ord a => Alt a -> a)
-> (forall a. Ord a => Alt a -> a)
-> (forall a. Num a => Alt a -> a)
-> (forall a. Num a => Alt a -> a)
-> Foldable Alt
forall a. Eq a => a -> Alt a -> Bool
forall a. Num a => Alt a -> a
forall a. Ord a => Alt a -> a
forall m. Monoid m => Alt m -> m
forall a. Alt a -> Bool
forall a. Alt a -> Int
forall a. Alt a -> [a]
forall a. (a -> a -> a) -> Alt a -> a
forall m a. Monoid m => (a -> m) -> Alt a -> m
forall b a. (b -> a -> b) -> b -> Alt a -> b
forall a b. (a -> b -> b) -> b -> Alt 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 :: Alt a -> a
$cproduct :: forall a. Num a => Alt a -> a
sum :: Alt a -> a
$csum :: forall a. Num a => Alt a -> a
minimum :: Alt a -> a
$cminimum :: forall a. Ord a => Alt a -> a
maximum :: Alt a -> a
$cmaximum :: forall a. Ord a => Alt a -> a
elem :: a -> Alt a -> Bool
$celem :: forall a. Eq a => a -> Alt a -> Bool
length :: Alt a -> Int
$clength :: forall a. Alt a -> Int
null :: Alt a -> Bool
$cnull :: forall a. Alt a -> Bool
toList :: Alt a -> [a]
$ctoList :: forall a. Alt a -> [a]
foldl1 :: (a -> a -> a) -> Alt a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Alt a -> a
foldr1 :: (a -> a -> a) -> Alt a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Alt a -> a
foldl' :: (b -> a -> b) -> b -> Alt a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Alt a -> b
foldl :: (b -> a -> b) -> b -> Alt a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Alt a -> b
foldr' :: (a -> b -> b) -> b -> Alt a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Alt a -> b
foldr :: (a -> b -> b) -> b -> Alt a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Alt a -> b
foldMap' :: (a -> m) -> Alt a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Alt a -> m
foldMap :: (a -> m) -> Alt a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Alt a -> m
fold :: Alt m -> m
$cfold :: forall m. Monoid m => Alt m -> m
Foldable, Functor Alt
Foldable Alt
Functor Alt
-> Foldable Alt
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Alt a -> f (Alt b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Alt (f a) -> f (Alt a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Alt a -> m (Alt b))
-> (forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a))
-> Traversable Alt
(a -> f b) -> Alt a -> f (Alt 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 => Alt (m a) -> m (Alt a)
forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Alt a -> m (Alt b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Alt a -> f (Alt b)
sequence :: Alt (m a) -> m (Alt a)
$csequence :: forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
mapM :: (a -> m b) -> Alt a -> m (Alt b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Alt a -> m (Alt b)
sequenceA :: Alt (f a) -> f (Alt a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
traverse :: (a -> f b) -> Alt a -> f (Alt b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Alt a -> f (Alt b)
$cp2Traversable :: Foldable Alt
$cp1Traversable :: Functor Alt
Traversable)


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


-- | The number of fields in a 'TypeVariant'.
variantFields :: TypeVariant -> Int
variantFields :: TypeVariant -> Int
variantFields (VariantNamed [(VarId, Type)]
fields) = [(VarId, Type)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(VarId, Type)]
fields
variantFields (VariantUnnamed [Type]
fields) = [Type] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Type]
fields


-- | Many data types carry other kinds of data, e.g., 'Expr' carries a type.
class Carrier c where
  -- | Extract the data carried by the carrier.
  extract :: c a -> a


  -- | Replace the data carried by the carrier.
  inject :: a -> c a -> c a


injectMore :: (Semigroup a, Carrier c) => a -> c a -> c a
injectMore :: a -> c a -> c a
injectMore a
a c a
c = a -> c a -> c a
forall (c :: * -> *) a. Carrier c => a -> c a -> c a
inject (a
a a -> a -> a
forall a. Semigroup a => a -> a -> a
<> c a -> a
forall (c :: * -> *) a. Carrier c => c a -> a
extract c a
c) c a
c


-- | Extract the type carried by an 'Expr'.
instance Carrier Expr where
  extract :: Expr a -> a
extract (Var VarId
_ a
t) = a
t
  extract (Data DConId
_ a
t) = a
t
  extract (Lit Literal
_ a
t) = a
t
  extract (Let [(Binder a, Expr a)]
_ Expr a
_ a
t) = a
t
  extract (Lambda Binder a
_ Expr a
_ a
t) = a
t
  extract (App Expr a
_ Expr a
_ a
t) = a
t
  extract (Match Expr a
_ [(Alt a, Expr a)]
_ a
t) = a
t
  extract (Prim Primitive
_ [Expr a]
_ a
t) = a
t
  extract (Exception ExceptType
_ a
t) = a
t


  inject :: a -> Expr a -> Expr a
inject a
t (Var VarId
v a
_) = VarId -> a -> Expr a
forall t. VarId -> t -> Expr t
Var VarId
v a
t
  inject a
t (Data DConId
d a
_) = DConId -> a -> Expr a
forall t. DConId -> t -> Expr t
Data DConId
d a
t
  inject a
t (Lit Literal
l a
_) = Literal -> a -> Expr a
forall t. Literal -> t -> Expr t
Lit Literal
l a
t
  inject a
t (Let [(Binder a, Expr a)]
ds Expr a
b a
_) = [(Binder a, Expr a)] -> Expr a -> a -> Expr a
forall t. [(Binder t, Expr t)] -> Expr t -> t -> Expr t
Let [(Binder a, Expr a)]
ds Expr a
b a
t
  inject a
t (Lambda Binder a
xs Expr a
b a
_) = Binder a -> Expr a -> a -> Expr a
forall t. Binder t -> Expr t -> t -> Expr t
Lambda Binder a
xs Expr a
b a
t
  inject a
t (App Expr a
h Expr a
a a
_) = Expr a -> Expr a -> a -> Expr a
forall t. Expr t -> Expr t -> t -> Expr t
App Expr a
h Expr a
a a
t
  inject a
t (Match Expr a
s [(Alt a, Expr a)]
as a
_) = Expr a -> [(Alt a, Expr a)] -> a -> Expr a
forall t. Expr t -> [(Alt t, Expr t)] -> t -> Expr t
Match Expr a
s [(Alt a, Expr a)]
as a
t
  inject a
t (Prim Primitive
p [Expr a]
es a
_) = Primitive -> [Expr a] -> a -> Expr a
forall t. Primitive -> [Expr t] -> t -> Expr t
Prim Primitive
p [Expr a]
es a
t
  inject a
t (Exception ExceptType
et a
_) = ExceptType -> a -> Expr a
forall t. ExceptType -> t -> Expr t
Exception ExceptType
et a
t


instance Carrier Alt where
  extract :: Alt a -> a
extract (AltData DConId
_ [Alt a]
_ a
t) = a
t
  extract (AltLit Literal
_ a
t) = a
t
  extract (AltBinder Binder a
b) = Binder a -> a
forall (c :: * -> *) a. Carrier c => c a -> a
extract Binder a
b
  inject :: a -> Alt a -> Alt a
inject a
t (AltData DConId
d [Alt a]
a a
_) = DConId -> [Alt a] -> a -> Alt a
forall t. DConId -> [Alt t] -> t -> Alt t
AltData DConId
d [Alt a]
a a
t
  inject a
t (AltLit Literal
l a
_) = Literal -> a -> Alt a
forall t. Literal -> t -> Alt t
AltLit Literal
l a
t
  inject a
t (AltBinder Binder a
b) = Binder a -> Alt a
forall t. Binder t -> Alt t
AltBinder (Binder a -> Alt a) -> Binder a -> Alt a
forall a b. (a -> b) -> a -> b
$ a -> Binder a -> Binder a
forall (c :: * -> *) a. Carrier c => a -> c a -> c a
inject a
t Binder a
b


instance Carrier Binder where
  extract :: Binder a -> a
extract Binder{_binderType :: forall a. Binder a -> a
_binderType = a
t} = a
t
  inject :: a -> Binder a -> Binder a
inject a
t Binder a
b = Binder a
b{_binderType :: a
_binderType = a
t}


{- | Collect a curried application into the function and argument list.

The type accompanying each argument represents type produced by the
application, and is extracted from the 'App' node that this function unwraps.

For example, the term @f a b@ (where @a: A@ and @b: B@) would be represented by
the following AST:
@@
(App (App (Var f (A -> B -> C)) (Var a A) (B -> C)) (Var b B) C)
@@

which, when unzipped, gives:

@@
(Var f (A -> B -> C)) [(Var a A, B -> C), (Var b B, C)]
@@

'unfoldApp' is the inverse of 'foldApp'.
-}
unfoldApp :: Expr t -> (Expr t, [(Expr t, t)])
unfoldApp :: Expr t -> (Expr t, [(Expr t, t)])
unfoldApp (App Expr t
lhs Expr t
rhs t
t) =
  let (Expr t
fn, [(Expr t, t)]
args) = Expr t -> (Expr t, [(Expr t, t)])
forall t. Expr t -> (Expr t, [(Expr t, t)])
unfoldApp Expr t
lhs in (Expr t
fn, [(Expr t, t)]
args [(Expr t, t)] -> [(Expr t, t)] -> [(Expr t, t)]
forall a. [a] -> [a] -> [a]
++ [(Expr t
rhs, t
t)])
unfoldApp Expr t
e = (Expr t
e, [])


{- | Apply a function to zero or more arguments.

'foldApp' is the inverse of 'unfoldApp'.
-}
foldApp :: Expr t -> [(Expr t, t)] -> Expr t
foldApp :: Expr t -> [(Expr t, t)] -> Expr t
foldApp = (Expr t -> (Expr t, t) -> Expr t)
-> Expr t -> [(Expr t, t)] -> Expr t
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl ((Expr t -> (Expr t, t) -> Expr t)
 -> Expr t -> [(Expr t, t)] -> Expr t)
-> (Expr t -> (Expr t, t) -> Expr t)
-> Expr t
-> [(Expr t, t)]
-> Expr t
forall a b. (a -> b) -> a -> b
$ \Expr t
f (Expr t
a, t
t) -> Expr t -> Expr t -> t -> Expr t
forall t. Expr t -> Expr t -> t -> Expr t
App Expr t
f Expr t
a t
t


-- | Collect a curried list of function arguments from a nesting of lambdas.
unfoldLambda :: Expr t -> ([Binder t], Expr t)
unfoldLambda :: Expr t -> ([Binder t], Expr t)
unfoldLambda (Lambda Binder t
a Expr t
b t
_) =
  let ([Binder t]
as, Expr t
body) = Expr t -> ([Binder t], Expr t)
forall t. Expr t -> ([Binder t], Expr t)
unfoldLambda Expr t
b in (Binder t
a Binder t -> [Binder t] -> [Binder t]
forall a. a -> [a] -> [a]
: [Binder t]
as, Expr t
body)
unfoldLambda Expr t
e = ([], Expr t
e)


-- | Create a lambda chain given a list of argument-type pairs and a body.
foldLambda :: [Binder Type] -> Expr Type -> Expr Type
foldLambda :: [Binder Type] -> Expr Type -> Expr Type
foldLambda [Binder Type]
args Expr Type
body = (Binder Type -> Expr Type -> Expr Type)
-> Expr Type -> [Binder Type] -> Expr Type
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Binder Type -> Expr Type -> Expr Type
chain Expr Type
body [Binder Type]
args
 where
  chain :: Binder Type -> Expr Type -> Expr Type
chain v :: Binder Type
v@(Binder Maybe VarId
_ Type
t) Expr Type
b = Binder Type -> Expr Type -> Type -> Expr Type
forall t. Binder t -> Expr t -> t -> Expr t
Lambda Binder Type
v Expr Type
b (Type -> Expr Type) -> Type -> Expr Type
forall a b. (a -> b) -> a -> b
$ Type
t Type -> Type -> Type
`Arrow` Expr Type -> Type
forall (c :: * -> *) a. Carrier c => c a -> a
extract Expr Type
b


-- | Whether an expression is a value.
isValue :: Expr t -> Bool
isValue :: Expr t -> Bool
isValue Var{} = Bool
True
isValue Data{} = Bool
True
isValue Lit{} = Bool
True
isValue Lambda{} = Bool
True
isValue Expr t
_ = Bool
False


-- | Retrieve list of binders from an 'Alt'.
altBinders :: Alt t -> [Binder t]
altBinders :: Alt t -> [Binder t]
altBinders (AltLit Literal
_ t
_) = []
altBinders (AltBinder Binder t
b) = [Binder t
b]
altBinders (AltData DConId
_ [Alt t]
as t
_) = (Alt t -> [Binder t]) -> [Alt t] -> [Binder t]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Alt t -> [Binder t]
forall t. Alt t -> [Binder t]
altBinders [Alt t]
as


binderToVar :: Binder a -> Maybe VarId
binderToVar :: Binder a -> Maybe VarId
binderToVar (BindVar VarId
v a
_) = VarId -> Maybe VarId
forall a. a -> Maybe a
Just VarId
v
binderToVar Binder a
_ = Maybe VarId
forall a. Maybe a
Nothing


uninitializedSymTable :: M.Map VarId (SymInfo t)
uninitializedSymTable :: Map VarId (SymInfo t)
uninitializedSymTable = Map VarId (SymInfo t)
forall k a. Map k a
M.empty


instance HasFreeVars (Expr t) VarId where
  freeVars :: Expr t -> Set VarId
freeVars (Var VarId
v t
_) = VarId -> Set VarId
forall a. a -> Set a
S.singleton VarId
v
  freeVars Data{} = Set VarId
forall a. Set a
S.empty
  freeVars Lit{} = Set VarId
forall a. Set a
S.empty
  freeVars (App Expr t
l Expr t
r t
_) = Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars Expr t
l Set VarId -> Set VarId -> Set VarId
forall a. Ord a => Set a -> Set a -> Set a
`S.union` Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars Expr t
r
  freeVars (Lambda (Maybe VarId -> [VarId]
forall a. Maybe a -> [a]
maybeToList (Maybe VarId -> [VarId])
-> (Binder t -> Maybe VarId) -> Binder t -> [VarId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Binder t -> Maybe VarId
forall t. Binder t -> Maybe VarId
_binderId -> [VarId]
v) Expr t
b t
_) = Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars Expr t
b Set VarId -> Set VarId -> Set VarId
forall a. Ord a => Set a -> Set a -> Set a
\\ [VarId] -> Set VarId
forall a. Ord a => [a] -> Set a
S.fromList [VarId]
v
  freeVars (Prim Primitive
_ [Expr t]
es t
_) = [Set VarId] -> Set VarId
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
S.unions ([Set VarId] -> Set VarId) -> [Set VarId] -> Set VarId
forall a b. (a -> b) -> a -> b
$ (Expr t -> Set VarId) -> [Expr t] -> [Set VarId]
forall a b. (a -> b) -> [a] -> [b]
map Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars [Expr t]
es
  freeVars (Let ([(Binder t, Expr t)] -> ([Binder t], [Expr t])
forall a b. [(a, b)] -> ([a], [b])
unzip -> ([Binder t]
bs, [Expr t]
ds)) Expr t
b t
_) =
    [Set VarId] -> Set VarId
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
S.unions ((Expr t -> Set VarId) -> [Expr t] -> [Set VarId]
forall a b. (a -> b) -> [a] -> [b]
map Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars ([Expr t] -> [Set VarId]) -> [Expr t] -> [Set VarId]
forall a b. (a -> b) -> a -> b
$ Expr t
b Expr t -> [Expr t] -> [Expr t]
forall a. a -> [a] -> [a]
: [Expr t]
ds) Set VarId -> Set VarId -> Set VarId
forall a. Ord a => Set a -> Set a -> Set a
\\ [VarId] -> Set VarId
forall a. Ord a => [a] -> Set a
S.fromList ([Maybe VarId] -> [VarId]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe VarId] -> [VarId]) -> [Maybe VarId] -> [VarId]
forall a b. (a -> b) -> a -> b
$ Binder t -> Maybe VarId
forall t. Binder t -> Maybe VarId
_binderId (Binder t -> Maybe VarId) -> [Binder t] -> [Maybe VarId]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Binder t]
bs)
  freeVars (Match Expr t
s [(Alt t, Expr t)]
as t
_) = [Set VarId] -> Set VarId
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
S.unions (Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars Expr t
s Set VarId -> [Set VarId] -> [Set VarId]
forall a. a -> [a] -> [a]
: ((Alt t, Expr t) -> Set VarId) -> [(Alt t, Expr t)] -> [Set VarId]
forall a b. (a -> b) -> [a] -> [b]
map (Alt t, Expr t) -> Set VarId
forall t. (Alt t, Expr t) -> Set VarId
freeAltVars [(Alt t, Expr t)]
as)
   where
    freeAltVars :: (Alt t, Expr t) -> S.Set VarId
    freeAltVars :: (Alt t, Expr t) -> Set VarId
freeAltVars (Alt t
a, Expr t
e) = Expr t -> Set VarId
forall t i. HasFreeVars t i => t -> Set i
freeVars Expr t
e Set VarId -> Set VarId -> Set VarId
forall a. Ord a => Set a -> Set a -> Set a
\\ [VarId] -> Set VarId
forall a. Ord a => [a] -> Set a
S.fromList ((Binder t -> Maybe VarId) -> [Binder t] -> [VarId]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Binder t -> Maybe VarId
forall t. Binder t -> Maybe VarId
_binderId ([Binder t] -> [VarId]) -> [Binder t] -> [VarId]
forall a b. (a -> b) -> a -> b
$ Alt t -> [Binder t]
forall t. Alt t -> [Binder t]
altBinders Alt t
a)
  freeVars Exception{} = Set VarId
forall a. Set a
S.empty