Safe Haskell  None 

Language  Haskell2010 
Synopsis
 data CondTree v c a = CondNode {
 condTreeData :: a
 condTreeConstraints :: c
 condTreeComponents :: [CondBranch v c a]
 data CondBranch v c a = CondBranch {
 condBranchCondition :: Condition v
 condBranchIfTrue :: CondTree v c a
 condBranchIfFalse :: Maybe (CondTree v c a)
 condIfThen :: Condition v > CondTree v c a > CondBranch v c a
 condIfThenElse :: Condition v > CondTree v c a > CondTree v c a > CondBranch v c a
 mapCondTree :: (a > b) > (c > d) > (Condition v > Condition w) > CondTree v c a > CondTree w d b
 mapTreeConstrs :: (c > d) > CondTree v c a > CondTree v d a
 mapTreeConds :: (Condition v > Condition w) > CondTree v c a > CondTree w c a
 mapTreeData :: (a > b) > CondTree v c a > CondTree v c b
 traverseCondTreeV :: Applicative f => (v > f w) > CondTree v c a > f (CondTree w c a)
 traverseCondBranchV :: Applicative f => (v > f w) > CondBranch v c a > f (CondBranch w c a)
 extractCondition :: Eq v => (a > Bool) > CondTree v c a > Condition v
 simplifyCondTree :: (Monoid a, Monoid d) => (v > Either v Bool) > CondTree v d a > (d, a)
 ignoreConditions :: (Monoid a, Monoid c) => CondTree v c a > (a, c)
Documentation
A CondTree
is used to represent the conditional structure of
a Cabal file, reflecting a syntax element subject to constraints,
and then any number of subelements which may be enabled subject
to some condition. Both a
and c
are usually Monoid
s.
To be more concrete, consider the following fragment of a Cabal
file:
builddepends: base >= 4.0 if flag(extra) builddepends: base >= 4.2
One way to represent this is to have
. Here, CondTree
ConfVar
[Dependency
] BuildInfo
condTreeData
represents
the actual fields which are not behind any conditional, while
condTreeComponents
recursively records any further fields
which are behind a conditional. condTreeConstraints
records
the constraints (in this case, base >= 4.0
) which would
be applied if you use this syntax; in general, this is
derived off of targetBuildInfo
(perhaps a good refactoring
would be to convert this into an opaque type, with a smart
constructor that precomputes the dependencies.)
CondNode  

Instances
Functor (CondTree v c) Source #  
Foldable (CondTree v c) Source #  
fold :: Monoid m => CondTree v c m > m # foldMap :: Monoid m => (a > m) > CondTree v c a > m # foldr :: (a > b > b) > b > CondTree v c a > b # foldr' :: (a > b > b) > b > CondTree v c a > b # foldl :: (b > a > b) > b > CondTree v c a > b # foldl' :: (b > a > b) > b > CondTree v c a > b # foldr1 :: (a > a > a) > CondTree v c a > a # foldl1 :: (a > a > a) > CondTree v c a > a # toList :: CondTree v c a > [a] # null :: CondTree v c a > Bool # length :: CondTree v c a > Int # elem :: Eq a => a > CondTree v c a > Bool # maximum :: Ord a => CondTree v c a > a # minimum :: Ord a => CondTree v c a > a #  
Traversable (CondTree v c) Source #  
(Eq a, Eq c, Eq v) => Eq (CondTree v c a) Source #  
(Data v, Data c, Data a) => Data (CondTree v c a) Source #  
gfoldl :: (forall d b. Data d => c0 (d > b) > d > c0 b) > (forall g. g > c0 g) > CondTree v c a > c0 (CondTree v c a) # gunfold :: (forall b r. Data b => c0 (b > r) > c0 r) > (forall r. r > c0 r) > Constr > c0 (CondTree v c a) # toConstr :: CondTree v c a > Constr # dataTypeOf :: CondTree v c a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) > Maybe (c0 (CondTree v c a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) > Maybe (c0 (CondTree v c a)) # gmapT :: (forall b. Data b => b > b) > CondTree v c a > CondTree v c a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > CondTree v c a > r # gmapQr :: (r' > r > r) > r > (forall d. Data d => d > r') > CondTree v c a > r # gmapQ :: (forall d. Data d => d > u) > CondTree v c a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > CondTree v c a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > CondTree v c a > m (CondTree v c a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > CondTree v c a > m (CondTree v c a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > CondTree v c a > m (CondTree v c a) #  
(Show a, Show c, Show v) => Show (CondTree v c a) Source #  
Generic (CondTree v c a) Source #  
(Binary v, Binary c, Binary a) => Binary (CondTree v c a) Source #  
(NFData v, NFData c, NFData a) => NFData (CondTree v c a) Source #  
type Rep (CondTree v c a) Source #  
type Rep (CondTree v c a) = D1 (MetaData "CondTree" "Distribution.Types.CondTree" "Cabal2.2.0.0inplace" False) (C1 (MetaCons "CondNode" PrefixI True) (S1 (MetaSel (Just "condTreeData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: (S1 (MetaSel (Just "condTreeConstraints") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c) :*: S1 (MetaSel (Just "condTreeComponents") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CondBranch v c a])))) 
data CondBranch v c a Source #
A CondBranch
represents a conditional branch, e.g., if
flag(foo)
on some syntax a
. It also has an optional false
branch.
CondBranch  

Instances
Functor (CondBranch v c) Source #  
fmap :: (a > b) > CondBranch v c a > CondBranch v c b # (<$) :: a > CondBranch v c b > CondBranch v c a #  
Foldable (CondBranch v c) Source #  
fold :: Monoid m => CondBranch v c m > m # foldMap :: Monoid m => (a > m) > CondBranch v c a > m # foldr :: (a > b > b) > b > CondBranch v c a > b # foldr' :: (a > b > b) > b > CondBranch v c a > b # foldl :: (b > a > b) > b > CondBranch v c a > b # foldl' :: (b > a > b) > b > CondBranch v c a > b # foldr1 :: (a > a > a) > CondBranch v c a > a # foldl1 :: (a > a > a) > CondBranch v c a > a # toList :: CondBranch v c a > [a] # null :: CondBranch v c a > Bool # length :: CondBranch v c a > Int # elem :: Eq a => a > CondBranch v c a > Bool # maximum :: Ord a => CondBranch v c a > a # minimum :: Ord a => CondBranch v c a > a # sum :: Num a => CondBranch v c a > a # product :: Num a => CondBranch v c a > a #  
Traversable (CondBranch v c) Source #  
traverse :: Applicative f => (a > f b) > CondBranch v c a > f (CondBranch v c b) # sequenceA :: Applicative f => CondBranch v c (f a) > f (CondBranch v c a) # mapM :: Monad m => (a > m b) > CondBranch v c a > m (CondBranch v c b) # sequence :: Monad m => CondBranch v c (m a) > m (CondBranch v c a) #  
(Eq v, Eq a, Eq c) => Eq (CondBranch v c a) Source #  
(==) :: CondBranch v c a > CondBranch v c a > Bool # (/=) :: CondBranch v c a > CondBranch v c a > Bool #  
(Data v, Data c, Data a) => Data (CondBranch v c a) Source #  
gfoldl :: (forall d b. Data d => c0 (d > b) > d > c0 b) > (forall g. g > c0 g) > CondBranch v c a > c0 (CondBranch v c a) # gunfold :: (forall b r. Data b => c0 (b > r) > c0 r) > (forall r. r > c0 r) > Constr > c0 (CondBranch v c a) # toConstr :: CondBranch v c a > Constr # dataTypeOf :: CondBranch v c a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) > Maybe (c0 (CondBranch v c a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) > Maybe (c0 (CondBranch v c a)) # gmapT :: (forall b. Data b => b > b) > CondBranch v c a > CondBranch v c a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > CondBranch v c a > r # gmapQr :: (r' > r > r) > r > (forall d. Data d => d > r') > CondBranch v c a > r # gmapQ :: (forall d. Data d => d > u) > CondBranch v c a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > CondBranch v c a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > CondBranch v c a > m (CondBranch v c a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > CondBranch v c a > m (CondBranch v c a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > CondBranch v c a > m (CondBranch v c a) #  
(Show v, Show a, Show c) => Show (CondBranch v c a) Source #  
showsPrec :: Int > CondBranch v c a > ShowS # show :: CondBranch v c a > String # showList :: [CondBranch v c a] > ShowS #  
Generic (CondBranch v c a) Source #  
type Rep (CondBranch v c a) :: * > * # from :: CondBranch v c a > Rep (CondBranch v c a) x # to :: Rep (CondBranch v c a) x > CondBranch v c a #  
(Binary v, Binary c, Binary a) => Binary (CondBranch v c a) Source #  
put :: CondBranch v c a > Put # get :: Get (CondBranch v c a) # putList :: [CondBranch v c a] > Put #  
(NFData v, NFData c, NFData a) => NFData (CondBranch v c a) Source #  
rnf :: CondBranch v c a > () #  
type Rep (CondBranch v c a) Source #  
type Rep (CondBranch v c a) = D1 (MetaData "CondBranch" "Distribution.Types.CondTree" "Cabal2.2.0.0inplace" False) (C1 (MetaCons "CondBranch" PrefixI True) (S1 (MetaSel (Just "condBranchCondition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Condition v)) :*: (S1 (MetaSel (Just "condBranchIfTrue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CondTree v c a)) :*: S1 (MetaSel (Just "condBranchIfFalse") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (CondTree v c a)))))) 
condIfThen :: Condition v > CondTree v c a > CondBranch v c a Source #
condIfThenElse :: Condition v > CondTree v c a > CondTree v c a > CondBranch v c a Source #
mapCondTree :: (a > b) > (c > d) > (Condition v > Condition w) > CondTree v c a > CondTree w d b Source #
mapTreeConstrs :: (c > d) > CondTree v c a > CondTree v d a Source #
mapTreeData :: (a > b) > CondTree v c a > CondTree v c b Source #
traverseCondTreeV :: Applicative f => (v > f w) > CondTree v c a > f (CondTree w c a) Source #
Traversal (CondTree v c a) (CondTree w c a) v w
traverseCondBranchV :: Applicative f => (v > f w) > CondBranch v c a > f (CondBranch w c a) Source #
Traversal (CondBranch v c a) (CondBranch w c a) v w
extractCondition :: Eq v => (a > Bool) > CondTree v c a > Condition v Source #
Extract the condition matched by the given predicate from a cond tree.
We use this mainly for extracting buildable conditions (see the Note above), but the function is in fact more general.