| Safe Haskell | None | 
|---|---|
| Language | Haskell2010 | 
Agda.TypeChecking.Coverage.SplitTree
Contents
Description
Split tree for transforming pattern clauses into case trees.
The coverage checker generates a split tree from the clauses. The clause compiler uses it to transform clauses to case trees.
The initial problem is a set of clauses. The root node designates on which argument to split and has subtrees for all the constructors. Splitting continues until there is only a single clause left at each leaf of the split tree.
Synopsis
- type SplitTree = SplitTree' SplitTag
 - type SplitTrees = SplitTrees' SplitTag
 - data SplitTree' a
- = SplittingDone { 
- splitBindings :: Int
 
 - | SplitAt { 
- splitArg :: Arg Int
 - splitLazy :: LazySplit
 - splitTrees :: SplitTrees' a
 
 
 - = SplittingDone { 
 - data LazySplit
 - type SplitTrees' a = [(a, SplitTree' a)]
 - data SplitTag
 - data SplitTreeLabel a = SplitTreeLabel {
- lblConstructorName :: Maybe a
 - lblSplitArg :: Maybe (Arg Int)
 - lblLazy :: LazySplit
 - lblBindings :: Maybe Int
 
 - toTree :: SplitTree' a -> Tree (SplitTreeLabel a)
 - toTrees :: SplitTrees' a -> Forest (SplitTreeLabel a)
 
Documentation
type SplitTree = SplitTree' SplitTag Source #
type SplitTrees = SplitTrees' SplitTag Source #
data SplitTree' a Source #
Abstract case tree shape.
Constructors
| SplittingDone | No more splits coming. We are at a single, all-variable clause.  | 
Fields 
  | |
| SplitAt | A split is necessary.  | 
Fields 
  | |
Instances
| DropArgs SplitTree Source # | |
| Data a => Data (SplitTree' a) Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SplitTree' a -> c (SplitTree' a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SplitTree' a) # toConstr :: SplitTree' a -> Constr # dataTypeOf :: SplitTree' a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SplitTree' a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SplitTree' a)) # gmapT :: (forall b. Data b => b -> b) -> SplitTree' a -> SplitTree' a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SplitTree' a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SplitTree' a -> r # gmapQ :: (forall d. Data d => d -> u) -> SplitTree' a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SplitTree' a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SplitTree' a -> m (SplitTree' a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SplitTree' a -> m (SplitTree' a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SplitTree' a -> m (SplitTree' a) #  | |
| Show a => Show (SplitTree' a) Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods showsPrec :: Int -> SplitTree' a -> ShowS # show :: SplitTree' a -> String # showList :: [SplitTree' a] -> ShowS #  | |
| Pretty a => Pretty (SplitTree' a) Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods pretty :: SplitTree' a -> Doc Source # prettyPrec :: Int -> SplitTree' a -> Doc Source # prettyList :: [SplitTree' a] -> Doc Source #  | |
| KillRange a => KillRange (SplitTree' a) Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods killRange :: KillRangeT (SplitTree' a) Source #  | |
| EmbPrj a => EmbPrj (SplitTree' a) Source # | |
Constructors
| LazySplit | |
| StrictSplit | 
Instances
| Eq LazySplit Source # | |
| Data LazySplit Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LazySplit -> c LazySplit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LazySplit # toConstr :: LazySplit -> Constr # dataTypeOf :: LazySplit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LazySplit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LazySplit) # gmapT :: (forall b. Data b => b -> b) -> LazySplit -> LazySplit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LazySplit -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LazySplit -> r # gmapQ :: (forall d. Data d => d -> u) -> LazySplit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LazySplit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LazySplit -> m LazySplit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LazySplit -> m LazySplit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LazySplit -> m LazySplit #  | |
| Ord LazySplit Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree  | |
| Show LazySplit Source # | |
| EmbPrj LazySplit Source # | |
type SplitTrees' a = [(a, SplitTree' a)] Source #
Split tree branching. A finite map from constructor names to splittrees A list representation seems appropriate, since we are expecting not so many constructors per data type, and there is no need for random access.
Tag for labeling branches of a split tree. Each branch is associated to either a constructor or a literal, or is a catchall branch (currently only used for splitting on a literal type).
Constructors
| SplitCon QName | |
| SplitLit Literal | |
| SplitCatchall | 
Instances
| Eq SplitTag Source # | |
| Data SplitTag Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SplitTag -> c SplitTag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SplitTag # toConstr :: SplitTag -> Constr # dataTypeOf :: SplitTag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SplitTag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SplitTag) # gmapT :: (forall b. Data b => b -> b) -> SplitTag -> SplitTag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SplitTag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SplitTag -> r # gmapQ :: (forall d. Data d => d -> u) -> SplitTag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SplitTag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SplitTag -> m SplitTag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SplitTag -> m SplitTag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SplitTag -> m SplitTag #  | |
| Ord SplitTag Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree  | |
| Show SplitTag Source # | |
| Pretty SplitTag Source # | |
| KillRange SplitTag Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods  | |
| EmbPrj SplitTag Source # | |
| PrettyTCM SplitTag Source # | |
Defined in Agda.TypeChecking.Pretty  | |
| DropArgs SplitTree Source # | |
Printing a split tree
data SplitTreeLabel a Source #
Constructors
| SplitTreeLabel | |
Fields 
  | |
Instances
| Pretty a => Pretty (SplitTreeLabel a) Source # | |
Defined in Agda.TypeChecking.Coverage.SplitTree Methods pretty :: SplitTreeLabel a -> Doc Source # prettyPrec :: Int -> SplitTreeLabel a -> Doc Source # prettyList :: [SplitTreeLabel a] -> Doc Source #  | |
toTree :: SplitTree' a -> Tree (SplitTreeLabel a) Source #
Convert a split tree into a Tree (for printing).
toTrees :: SplitTrees' a -> Forest (SplitTreeLabel a) Source #