{-# LANGUAGE DeriveDataTypeable #-}
-- | Sslang abstract syntax tree.
module Front.Ast where

import           Common.Identifiers             ( Identifiable(..)
                                                , Identifier
                                                )
import           Common.Pretty

import           Data.Generics
import           Data.List                      ( intersperse )
import           Data.Maybe                     ( mapMaybe )

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

-- | A top-level definition.
data TopDef
  = TopDef Definition     -- ^ Bind a (data) value to a variable
  | TopType TypeDef       -- ^ Define an algebraic data type
  | TopCDefs String       -- ^ Inlined block of C definitions
  | TopExtern ExternDecl  -- ^ Declare external symbol for FFI
  deriving (TopDef -> TopDef -> Bool
(TopDef -> TopDef -> Bool)
-> (TopDef -> TopDef -> Bool) -> Eq TopDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TopDef -> TopDef -> Bool
$c/= :: TopDef -> TopDef -> Bool
== :: TopDef -> TopDef -> Bool
$c== :: TopDef -> TopDef -> Bool
Eq, Int -> TopDef -> ShowS
[TopDef] -> ShowS
TopDef -> String
(Int -> TopDef -> ShowS)
-> (TopDef -> String) -> ([TopDef] -> ShowS) -> Show TopDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TopDef] -> ShowS
$cshowList :: [TopDef] -> ShowS
show :: TopDef -> String
$cshow :: TopDef -> String
showsPrec :: Int -> TopDef -> ShowS
$cshowsPrec :: Int -> TopDef -> ShowS
Show, Typeable, Typeable TopDef
DataType
Constr
Typeable TopDef
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TopDef -> c TopDef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TopDef)
-> (TopDef -> Constr)
-> (TopDef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TopDef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TopDef))
-> ((forall b. Data b => b -> b) -> TopDef -> TopDef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TopDef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TopDef -> r)
-> (forall u. (forall d. Data d => d -> u) -> TopDef -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TopDef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TopDef -> m TopDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TopDef -> m TopDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TopDef -> m TopDef)
-> Data TopDef
TopDef -> DataType
TopDef -> Constr
(forall b. Data b => b -> b) -> TopDef -> TopDef
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TopDef -> c TopDef
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TopDef
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) -> TopDef -> u
forall u. (forall d. Data d => d -> u) -> TopDef -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TopDef -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TopDef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TopDef -> m TopDef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TopDef -> m TopDef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TopDef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TopDef -> c TopDef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TopDef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TopDef)
$cTopExtern :: Constr
$cTopCDefs :: Constr
$cTopType :: Constr
$cTopDef :: Constr
$tTopDef :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TopDef -> m TopDef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TopDef -> m TopDef
gmapMp :: (forall d. Data d => d -> m d) -> TopDef -> m TopDef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TopDef -> m TopDef
gmapM :: (forall d. Data d => d -> m d) -> TopDef -> m TopDef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TopDef -> m TopDef
gmapQi :: Int -> (forall d. Data d => d -> u) -> TopDef -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TopDef -> u
gmapQ :: (forall d. Data d => d -> u) -> TopDef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TopDef -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TopDef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TopDef -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TopDef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TopDef -> r
gmapT :: (forall b. Data b => b -> b) -> TopDef -> TopDef
$cgmapT :: (forall b. Data b => b -> b) -> TopDef -> TopDef
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TopDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TopDef)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TopDef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TopDef)
dataTypeOf :: TopDef -> DataType
$cdataTypeOf :: TopDef -> DataType
toConstr :: TopDef -> Constr
$ctoConstr :: TopDef -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TopDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TopDef
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TopDef -> c TopDef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TopDef -> c TopDef
$cp1Data :: Typeable TopDef
Data)

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

-- | An algebraic data type definition.
data TypeDef = TypeDef
  { TypeDef -> Identifier
typeName     :: Identifier      -- ^ The name of the type, e.g., @Option@
  , TypeDef -> [Identifier]
typeParams   :: [Identifier]    -- ^ List of type parameters, e.g., @a@
  , TypeDef -> [TypeVariant]
typeVariants :: [TypeVariant]   -- ^ List of variants, e.g., @Some@, @None@
  }
  deriving (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, 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, 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)

-- | A type variant, i.e., a data constructor.
data TypeVariant = VariantUnnamed Identifier [Typ]
  deriving (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, 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, 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
$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 value definition.
data Definition
  = DefFn Identifier [Pat] TypFn Expr
  | DefPat Pat Expr
  deriving (Definition -> Definition -> Bool
(Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool) -> Eq Definition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Definition -> Definition -> Bool
$c/= :: Definition -> Definition -> Bool
== :: Definition -> Definition -> Bool
$c== :: Definition -> Definition -> Bool
Eq, Int -> Definition -> ShowS
[Definition] -> ShowS
Definition -> String
(Int -> Definition -> ShowS)
-> (Definition -> String)
-> ([Definition] -> ShowS)
-> Show Definition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Definition] -> ShowS
$cshowList :: [Definition] -> ShowS
show :: Definition -> String
$cshow :: Definition -> String
showsPrec :: Int -> Definition -> ShowS
$cshowsPrec :: Int -> Definition -> ShowS
Show, Typeable, Typeable Definition
DataType
Constr
Typeable Definition
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Definition -> c Definition)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Definition)
-> (Definition -> Constr)
-> (Definition -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Definition))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Definition))
-> ((forall b. Data b => b -> b) -> Definition -> Definition)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Definition -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Definition -> r)
-> (forall u. (forall d. Data d => d -> u) -> Definition -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Definition -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> Data Definition
Definition -> DataType
Definition -> Constr
(forall b. Data b => b -> b) -> Definition -> Definition
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
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) -> Definition -> u
forall u. (forall d. Data d => d -> u) -> Definition -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Definition)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
$cDefPat :: Constr
$cDefFn :: Constr
$tDefinition :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapMp :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapM :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapQi :: Int -> (forall d. Data d => d -> u) -> Definition -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Definition -> u
gmapQ :: (forall d. Data d => d -> u) -> Definition -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Definition -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
gmapT :: (forall b. Data b => b -> b) -> Definition -> Definition
$cgmapT :: (forall b. Data b => b -> b) -> Definition -> Definition
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Definition)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Definition)
dataTypeOf :: Definition -> DataType
$cdataTypeOf :: Definition -> DataType
toConstr :: Definition -> Constr
$ctoConstr :: Definition -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
$cp1Data :: Typeable Definition
Data)

-- | A pattern appearing on the LHS of a definition or match arm
data Pat
  = PatWildcard           -- ^ Match anything, i.e., @_@
  | PatId Identifier      -- ^ Variable or data constructor, e.g., @v@ or @Some@
  | PatLit Literal        -- ^ Literal match, e.g., @1@
  | PatAs Identifier Pat  -- ^ Pattern alias, e.g., @a \@ <pat>@
  | PatTup [Pat]          -- ^ Match on a tuple, e.g., @(<pat>, <pat>)@
  | PatApp [Pat]          -- ^ Match on multiple patterns, e.g., @Some a@
  | PatAnn Typ Pat        -- ^ Match with type annotation, e.g., @<pat>: Type@
  deriving (Pat -> Pat -> Bool
(Pat -> Pat -> Bool) -> (Pat -> Pat -> Bool) -> Eq Pat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pat -> Pat -> Bool
$c/= :: Pat -> Pat -> Bool
== :: Pat -> Pat -> Bool
$c== :: Pat -> Pat -> Bool
Eq, Int -> Pat -> ShowS
[Pat] -> ShowS
Pat -> String
(Int -> Pat -> ShowS)
-> (Pat -> String) -> ([Pat] -> ShowS) -> Show Pat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pat] -> ShowS
$cshowList :: [Pat] -> ShowS
show :: Pat -> String
$cshow :: Pat -> String
showsPrec :: Int -> Pat -> ShowS
$cshowsPrec :: Int -> Pat -> ShowS
Show, Typeable, Typeable Pat
DataType
Constr
Typeable Pat
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat -> c Pat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pat)
-> (Pat -> Constr)
-> (Pat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat))
-> ((forall b. Data b => b -> b) -> Pat -> Pat)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pat -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> Data Pat
Pat -> DataType
Pat -> Constr
(forall b. Data b => b -> b) -> Pat -> Pat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
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) -> Pat -> u
forall u. (forall d. Data d => d -> u) -> Pat -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cPatAnn :: Constr
$cPatApp :: Constr
$cPatTup :: Constr
$cPatAs :: Constr
$cPatLit :: Constr
$cPatId :: Constr
$cPatWildcard :: Constr
$tPat :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapMp :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapM :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
$cgmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
dataTypeOf :: Pat -> DataType
$cdataTypeOf :: Pat -> DataType
toConstr :: Pat -> Constr
$ctoConstr :: Pat -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cp1Data :: Typeable Pat
Data)

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

-- | TODO: type classes
type TypAnn = Typ

-- | A type definition
data Typ
  = TCon Identifier
  | TApp Typ Typ
  | TTuple [Typ]
  | TArrow Typ Typ
  -- TODO type variables
  deriving (Typ -> Typ -> Bool
(Typ -> Typ -> Bool) -> (Typ -> Typ -> Bool) -> Eq Typ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Typ -> Typ -> Bool
$c/= :: Typ -> Typ -> Bool
== :: Typ -> Typ -> Bool
$c== :: Typ -> Typ -> Bool
Eq, Int -> Typ -> ShowS
[Typ] -> ShowS
Typ -> String
(Int -> Typ -> ShowS)
-> (Typ -> String) -> ([Typ] -> ShowS) -> Show Typ
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Typ] -> ShowS
$cshowList :: [Typ] -> ShowS
show :: Typ -> String
$cshow :: Typ -> String
showsPrec :: Int -> Typ -> ShowS
$cshowsPrec :: Int -> Typ -> ShowS
Show, Typeable, Typeable Typ
DataType
Constr
Typeable Typ
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Typ -> c Typ)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Typ)
-> (Typ -> Constr)
-> (Typ -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Typ))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Typ))
-> ((forall b. Data b => b -> b) -> Typ -> Typ)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r)
-> (forall u. (forall d. Data d => d -> u) -> Typ -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Typ -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Typ -> m Typ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Typ -> m Typ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Typ -> m Typ)
-> Data Typ
Typ -> DataType
Typ -> Constr
(forall b. Data b => b -> b) -> Typ -> Typ
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typ -> c Typ
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Typ
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) -> Typ -> u
forall u. (forall d. Data d => d -> u) -> Typ -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Typ -> m Typ
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Typ -> m Typ
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Typ
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typ -> c Typ
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Typ)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Typ)
$cTArrow :: Constr
$cTTuple :: Constr
$cTApp :: Constr
$cTCon :: Constr
$tTyp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Typ -> m Typ
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Typ -> m Typ
gmapMp :: (forall d. Data d => d -> m d) -> Typ -> m Typ
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Typ -> m Typ
gmapM :: (forall d. Data d => d -> m d) -> Typ -> m Typ
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Typ -> m Typ
gmapQi :: Int -> (forall d. Data d => d -> u) -> Typ -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Typ -> u
gmapQ :: (forall d. Data d => d -> u) -> Typ -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Typ -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typ -> r
gmapT :: (forall b. Data b => b -> b) -> Typ -> Typ
$cgmapT :: (forall b. Data b => b -> b) -> Typ -> Typ
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Typ)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Typ)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Typ)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Typ)
dataTypeOf :: Typ -> DataType
$cdataTypeOf :: Typ -> DataType
toConstr :: Typ -> Constr
$ctoConstr :: Typ -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Typ
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Typ
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typ -> c Typ
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Typ -> c Typ
$cp1Data :: Typeable Typ
Data)

-- | An expression
data Expr
  = Id Identifier
  | Lit Literal
  | Apply Expr Expr
  | Lambda [Pat] Expr
  | OpRegion Expr OpRegion
  | NoExpr
  | Let [Definition] Expr
  | While Expr Expr
  | Loop Expr
  | Par [Expr]
  | IfElse Expr Expr Expr
  | After Expr Expr Expr
  | Assign Expr Expr
  | Constraint Expr TypAnn
  | Wait [Expr]
  | Seq Expr Expr
  | Break
  | Match Expr [(Pat, Expr)]
  | CQuote String
  | CCall Identifier [Expr]
  | Tuple [Expr]
  | ListExpr [Expr]
  | Last Expr
  | Now
  deriving (Expr -> Expr -> Bool
(Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expr -> Expr -> Bool
$c/= :: Expr -> Expr -> Bool
== :: Expr -> Expr -> Bool
$c== :: Expr -> Expr -> Bool
Eq, Int -> Expr -> ShowS
[Expr] -> ShowS
Expr -> String
(Int -> Expr -> ShowS)
-> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expr] -> ShowS
$cshowList :: [Expr] -> ShowS
show :: Expr -> String
$cshow :: Expr -> String
showsPrec :: Int -> Expr -> ShowS
$cshowsPrec :: Int -> Expr -> ShowS
Show, Typeable, Typeable Expr
DataType
Constr
Typeable Expr
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr)
-> (Expr -> Constr)
-> (Expr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr))
-> ((forall b. Data b => b -> b) -> Expr -> Expr)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> Data Expr
Expr -> DataType
Expr -> Constr
(forall b. Data b => b -> b) -> Expr -> Expr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
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 -> u
forall u. (forall d. Data d => d -> u) -> Expr -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cNow :: Constr
$cLast :: Constr
$cListExpr :: Constr
$cTuple :: Constr
$cCCall :: Constr
$cCQuote :: Constr
$cMatch :: Constr
$cBreak :: Constr
$cSeq :: Constr
$cWait :: Constr
$cConstraint :: Constr
$cAssign :: Constr
$cAfter :: Constr
$cIfElse :: Constr
$cPar :: Constr
$cLoop :: Constr
$cWhile :: Constr
$cLet :: Constr
$cNoExpr :: Constr
$cOpRegion :: Constr
$cLambda :: Constr
$cApply :: Constr
$cLit :: Constr
$cId :: Constr
$tExpr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapMp :: (forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapM :: (forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
gmapQ :: (forall d. Data d => d -> u) -> Expr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
$cgmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Expr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
dataTypeOf :: Expr -> DataType
$cdataTypeOf :: Expr -> DataType
toConstr :: Expr -> Constr
$ctoConstr :: Expr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
$cp1Data :: Typeable Expr
Data)

{- | An operator region: a flat list of alternating expressions and operators
that is initially parsed flat but will be restructured into a tree by
the operator precedence parser.
-}
data OpRegion
  = NextOp Identifier Expr OpRegion
  | EOR
  deriving (OpRegion -> OpRegion -> Bool
(OpRegion -> OpRegion -> Bool)
-> (OpRegion -> OpRegion -> Bool) -> Eq OpRegion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OpRegion -> OpRegion -> Bool
$c/= :: OpRegion -> OpRegion -> Bool
== :: OpRegion -> OpRegion -> Bool
$c== :: OpRegion -> OpRegion -> Bool
Eq, Int -> OpRegion -> ShowS
[OpRegion] -> ShowS
OpRegion -> String
(Int -> OpRegion -> ShowS)
-> (OpRegion -> String) -> ([OpRegion] -> ShowS) -> Show OpRegion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OpRegion] -> ShowS
$cshowList :: [OpRegion] -> ShowS
show :: OpRegion -> String
$cshow :: OpRegion -> String
showsPrec :: Int -> OpRegion -> ShowS
$cshowsPrec :: Int -> OpRegion -> ShowS
Show, Typeable, Typeable OpRegion
DataType
Constr
Typeable OpRegion
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> OpRegion -> c OpRegion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OpRegion)
-> (OpRegion -> Constr)
-> (OpRegion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OpRegion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpRegion))
-> ((forall b. Data b => b -> b) -> OpRegion -> OpRegion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OpRegion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OpRegion -> r)
-> (forall u. (forall d. Data d => d -> u) -> OpRegion -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OpRegion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OpRegion -> m OpRegion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OpRegion -> m OpRegion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OpRegion -> m OpRegion)
-> Data OpRegion
OpRegion -> DataType
OpRegion -> Constr
(forall b. Data b => b -> b) -> OpRegion -> OpRegion
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpRegion -> c OpRegion
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpRegion
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) -> OpRegion -> u
forall u. (forall d. Data d => d -> u) -> OpRegion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OpRegion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OpRegion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpRegion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpRegion -> c OpRegion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OpRegion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpRegion)
$cEOR :: Constr
$cNextOp :: Constr
$tOpRegion :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
gmapMp :: (forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
gmapM :: (forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OpRegion -> m OpRegion
gmapQi :: Int -> (forall d. Data d => d -> u) -> OpRegion -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OpRegion -> u
gmapQ :: (forall d. Data d => d -> u) -> OpRegion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OpRegion -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OpRegion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OpRegion -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OpRegion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OpRegion -> r
gmapT :: (forall b. Data b => b -> b) -> OpRegion -> OpRegion
$cgmapT :: (forall b. Data b => b -> b) -> OpRegion -> OpRegion
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpRegion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpRegion)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OpRegion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OpRegion)
dataTypeOf :: OpRegion -> DataType
$cdataTypeOf :: OpRegion -> DataType
toConstr :: OpRegion -> Constr
$ctoConstr :: OpRegion -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpRegion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpRegion
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpRegion -> c OpRegion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpRegion -> c OpRegion
$cp1Data :: Typeable OpRegion
Data)

-- | A literal
data Literal
  = LitInt Integer
  | LitString String
  | LitRat Rational
  | LitChar Char
  | 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
$cLitChar :: Constr
$cLitRat :: Constr
$cLitString :: Constr
$cLitInt :: 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)

-- | Fixity declaration for binary operators.
data Fixity = Infixl Int Identifier
            | Infixr Int Identifier

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

Suppose we have as source code
@
type Color = RGB Int Int Int
...
    let x = RGB 203 200 100
@
and rgb = Id "RGB"
    r = Lit (A.LitInt 203)
    g = Lit (A.LitInt 200)
    b = Lit (A.LitInt 100),
then foldApp rgb [r, g, b] returns
@
Apply (Apply (Apply (Id RGB) (Lit (LitInt 100))) (Lit (LitInt 200))) (Lit (LitInt 203))
@
-}
foldApp :: Expr -> [Expr] -> Expr
foldApp :: Expr -> [Expr] -> Expr
foldApp = (Expr -> Expr -> Expr) -> Expr -> [Expr] -> Expr
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((Expr -> Expr -> Expr) -> Expr -> [Expr] -> Expr)
-> (Expr -> Expr -> Expr) -> Expr -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ \Expr
a Expr
f -> Expr -> Expr -> Expr
Apply Expr
f Expr
a

-- | Collect a type application into the type constructor and its arguments.
collectTApp :: Typ -> (Typ, [Typ])
collectTApp :: Typ -> (Typ, [Typ])
collectTApp (TApp Typ
lhs Typ
rhs) = (Typ
lf, [Typ]
la [Typ] -> [Typ] -> [Typ]
forall a. [a] -> [a] -> [a]
++ [Typ
rhs])
  where (Typ
lf, [Typ]
la) = Typ -> (Typ, [Typ])
collectTApp Typ
lhs
collectTApp Typ
t = (Typ
t, [])

-- | Collect a curried application into the function and its list of arguments.
collectApp :: Expr -> (Expr, [Expr])
collectApp :: Expr -> (Expr, [Expr])
collectApp (Apply Expr
lhs Expr
rhs) = (Expr
lf, [Expr]
la [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Expr
rhs]) where (Expr
lf, [Expr]
la) = Expr -> (Expr, [Expr])
collectApp Expr
lhs
collectApp Expr
t               = (Expr
t, [])

-- | Collect a pattern application into the destructor and arguments.
collectPApp :: Pat -> (Pat, [Pat])
collectPApp :: Pat -> (Pat, [Pat])
collectPApp (PatApp (Pat
p : [Pat]
ps)) = (Pat
p, [Pat]
ps)
collectPApp Pat
p                 = (Pat
p, []) -- Note that @PatApp []@ is probably malformed!

-- | Unwrap a (potential) top-level data definition.
getTopDataDef :: TopDef -> Maybe Definition
getTopDataDef :: TopDef -> Maybe Definition
getTopDataDef (TopDef Definition
d) = Definition -> Maybe Definition
forall a. a -> Maybe a
Just Definition
d
getTopDataDef TopDef
_          = Maybe Definition
forall a. Maybe a
Nothing

-- | Unwrap a (potential) top-level type definition.
getTopTypeDef :: TopDef -> Maybe TypeDef
getTopTypeDef :: TopDef -> Maybe TypeDef
getTopTypeDef (TopType TypeDef
t) = TypeDef -> Maybe TypeDef
forall a. a -> Maybe a
Just TypeDef
t
getTopTypeDef TopDef
_           = Maybe TypeDef
forall a. Maybe a
Nothing

-- | Unwrap a (potential) top-level C inline block.
getTopCDefs :: TopDef -> Maybe String
getTopCDefs :: TopDef -> Maybe String
getTopCDefs (TopCDefs String
b) = String -> Maybe String
forall a. a -> Maybe a
Just String
b
getTopCDefs TopDef
_            = Maybe String
forall a. Maybe a
Nothing

-- | Unwrap a (potential) top-level external definition.
getTopExtern :: TopDef -> Maybe ExternDecl
getTopExtern :: TopDef -> Maybe ExternDecl
getTopExtern (TopExtern ExternDecl
d) = ExternDecl -> Maybe ExternDecl
forall a. a -> Maybe a
Just ExternDecl
d
getTopExtern TopDef
_             = Maybe ExternDecl
forall a. Maybe a
Nothing

-- | Unzip a list of top-level declarations into their counterparts.
getTops :: [TopDef] -> ([TypeDef], [String], [ExternDecl], [Definition])
getTops :: [TopDef] -> ([TypeDef], [String], [ExternDecl], [Definition])
getTops [TopDef]
tds =
  ( (TopDef -> Maybe TypeDef) -> [TopDef] -> [TypeDef]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TopDef -> Maybe TypeDef
getTopTypeDef [TopDef]
tds
  , (TopDef -> Maybe String) -> [TopDef] -> [String]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TopDef -> Maybe String
getTopCDefs   [TopDef]
tds
  , (TopDef -> Maybe ExternDecl) -> [TopDef] -> [ExternDecl]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TopDef -> Maybe ExternDecl
getTopExtern  [TopDef]
tds
  , (TopDef -> Maybe Definition) -> [TopDef] -> [Definition]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TopDef -> Maybe Definition
getTopDataDef [TopDef]
tds
  )

instance Pretty Program where
  pretty :: Program -> Doc ann
pretty (Program [TopDef]
defs) = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep (Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
intersperse Doc ann
forall ann. Doc ann
emptyDoc ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (TopDef -> Doc ann) -> [TopDef] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map TopDef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [TopDef]
defs)

instance Pretty TopDef where
  pretty :: TopDef -> Doc ann
pretty (TopDef    Definition
d ) = Definition -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Definition
d
  pretty (TopType   TypeDef
t ) = TypeDef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty TypeDef
t
  pretty (TopCDefs  String
ds) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"$$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
ds Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"$$"
  pretty (TopExtern ExternDecl
x ) = ExternDecl -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ExternDecl
x

instance Pretty ExternDecl where
  pretty :: ExternDecl -> Doc ann
pretty (ExternDecl Identifier
i Typ
t) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"extern" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
i Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
colon Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t

instance Pretty TypeDef where
  pretty :: TypeDef -> Doc ann
pretty TypeDef { typeName :: TypeDef -> Identifier
typeName = Identifier
tn, typeParams :: TypeDef -> [Identifier]
typeParams = [Identifier]
tvs, typeVariants :: TypeDef -> [TypeVariant]
typeVariants = [TypeVariant]
tds } =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep (Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
tn Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
: (Identifier -> Doc ann) -> [Identifier] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Identifier]
tvs) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
equals Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces
      ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
bar ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (TypeVariant -> Doc ann) -> [TypeVariant] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map TypeVariant -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [TypeVariant]
tds)

instance Pretty TypeVariant where
  pretty :: TypeVariant -> Doc ann
pretty (VariantUnnamed Identifier
dc [Typ]
vs) = Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
dc Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Typ -> Doc ann) -> [Typ] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Typ]
vs)

instance Pretty Definition where
  pretty :: Definition -> Doc ann
pretty (DefFn Identifier
fid [Pat]
formals TypFn
r Expr
body) =
    Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
fid
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> (Pat -> Doc ann) -> Pat -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty) [Pat]
formals)
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> TypFn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty TypFn
r
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
equals
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
body)

  pretty (DefPat Pat
b Expr
body) = Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Pat
b Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
equals Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
body)

instance Pretty Pat where
  pretty :: Pat -> Doc ann
pretty Pat
PatWildcard   = Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
'_'
  pretty (PatId  Identifier
s   ) = Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
s
  pretty (PatApp [Pat]
ps  ) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Pat]
ps
  pretty (PatLit Literal
l   ) = Literal -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Literal
l
  pretty (PatAs Identifier
b Pat
p  ) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
b Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
'@' Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Pat
p
  pretty (PatTup [Pat]
bs  ) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Pat]
bs)
  pretty (PatAnn Typ
ty Pat
p) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Pat
p Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
colon Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
ty

instance Pretty TypFn where
  pretty :: TypFn -> Doc ann
pretty (TypReturn Typ
t) = Doc ann
forall ann. Doc ann
rarrow Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t
  pretty (TypProper Typ
t) = Doc ann
forall ann. Doc ann
colon Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t
  pretty TypFn
TypNone       = Doc ann
forall ann. Doc ann
emptyDoc

instance Pretty Typ where
  pretty :: Typ -> Doc ann
pretty (TTuple [Typ]
tys) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Typ -> Doc ann) -> [Typ] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Typ]
tys)
  pretty (TCon   Identifier
cid) = Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
cid
  pretty (TApp (TCon Identifier
tc) Typ
t2) | Identifier -> String
forall i. Identifiable i => i -> String
ident Identifier
tc String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[]" = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t2
                             | Identifier -> String
forall i. Identifiable i => i -> String
ident Identifier
tc String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"&"  = Doc ann
forall ann. Doc ann
amp Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t2
  pretty (TApp   Typ
t1 Typ
t2) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t2
  pretty (TArrow Typ
t1 Typ
t2) = Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
rarrow Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t2


instance Pretty Expr where
  pretty :: Expr -> Doc ann
pretty (Tuple [Expr]
elts) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Expr -> Doc ann) -> [Expr] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Expr]
elts)
  pretty (Let [Definition]
defs Expr
body) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"let"
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
dbar ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Definition -> Doc ann) -> [Definition] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Definition -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Definition]
defs)
      Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>  Doc ann
forall ann. Doc ann
semi
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
body
  pretty (Seq Expr
e1 Expr
e2) = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep [Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1 Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
semi, Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e2]
  pretty (After Expr
e1 Expr
v Expr
e2) =
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens
      (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$   String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"after"
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
comma
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
v
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
larrow
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e2)
  pretty (Assign     Expr
v  Expr
e) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
v Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
larrow Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e)
  pretty (Constraint Expr
e  Typ
t) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
forall ann. Doc ann
colon Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Typ -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Typ
t
  pretty (OpRegion   Expr
e1 OpRegion
r) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1 Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> OpRegion -> Doc ann
forall ann. OpRegion -> Doc ann
p OpRegion
r
   where
    p :: OpRegion -> Doc ann
p OpRegion
EOR             = Doc ann
forall ann. Doc ann
emptyDoc
    p (NextOp Identifier
s Expr
e OpRegion
r') = Doc ann
forall ann. Doc ann
space Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
s Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> OpRegion -> Doc ann
p OpRegion
r'
  pretty (IfElse Expr
e1 Expr
e2 Expr
NoExpr) =
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"if" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e2)
  pretty (IfElse Expr
e1 Expr
e2 Expr
e3) =
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens
      (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$   String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"if"
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e2)
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"else"
      Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e3)
  pretty (While Expr
e1 Expr
e2) =
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"while" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e2)
  pretty (Loop Expr
e ) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"loop" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e)
  pretty (Par  [Expr]
es) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"par" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Doc ann) -> [Expr] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Expr]
es)
  pretty (Wait [Expr]
vars) =
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"wait" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep (Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Expr -> Doc ann) -> [Expr] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Expr]
vars)
  pretty (Lambda [Pat]
ps Expr
b) =
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"fun" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((Pat -> Doc ann) -> [Pat] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> (Pat -> Doc ann) -> Pat -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty) [Pat]
ps) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces
      (Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
b)
  pretty (Apply Expr
e1 Expr
e2) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e1 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e2
  pretty (Id  Identifier
i      ) = Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
i
  pretty (Lit Literal
l      ) = Literal -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Literal
l
  pretty Expr
Break         = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"break"
  -- TODO: we should replace every '$$' in s with '$$$$'
  pretty (CQuote String
s)    = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"$$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
s Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"$$"
  pretty (CCall Identifier
s [Expr]
as) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Identifier -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Identifier
s Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Expr -> Doc ann) -> [Expr] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Expr]
as)
  pretty (Match Expr
s [(Pat, Expr)]
as) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"match" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
s Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces
    ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
bar ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ ((Pat, Expr) -> Doc ann) -> [(Pat, Expr)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map (Pat, Expr) -> Doc ann
forall a a ann. (Pretty a, Pretty a) => (a, a) -> Doc ann
prettyPatExprTup [(Pat, Expr)]
as)
   where
    prettyPatExprTup :: (a, a) -> Doc ann
prettyPatExprTup (a
p, a
e) = a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
p Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"=" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
e)
  pretty (ListExpr [Expr]
es) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> [Doc ann]) -> [Doc ann] -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ (Expr -> Doc ann) -> [Expr] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Expr]
es
  pretty Expr
Now           = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"now"
  pretty (Last Expr
e)      = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"@@" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Expr -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Expr
e
  pretty Expr
NoExpr        = String -> Doc ann
forall a. HasCallStack => String -> a
error String
"Unexpected NoExpr"

instance Pretty Literal where
  pretty :: Literal -> Doc ann
pretty (LitInt    Integer
i) = Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
i
  pretty (LitString String
s) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
dquotes (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
s
  pretty (LitRat    Rational
r) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> String -> Doc ann
forall a b. (a -> b) -> a -> b
$ Rational -> String
forall a. Show a => a -> String
show Rational
r
  pretty (LitChar   Char
c) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
squotes (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
c
  pretty Literal
LitEvent      = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"()"

instance Dumpy Program  where
  dumpy :: Program -> Doc ann
dumpy = Program -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty