Now fixed!! --Joey

Currently, Info about a Host's Properties is propagated to the host by examining the tree of Properties.

This works, but there's one problem. Consider this example:

withOS desc $ \o -> case o of
            (Just (System (Debian Unstable) _)) -> ensureProperty foo
    _ -> ensureProperty bar

Here, the Info of foo is not propagated out. Nor is bar's Info. It's not really clear if just one Info, or both should be propagated out.

---

One approach might be to make the Propellor monad be able to be run in two modes. In run mode, it actually performs IO, etc. In introspection mode, all liftIO is a no-op, but all Info encountered is accumulated using a Reader. This might need two separate monad definitions.

That is surely doable, but consider this example:

property "demo" = do
    needfoo <- liftIO checkFoo
    if needfoo
        then ensureProperty foo
        else ensureProperty . bar =<< liftIO (getBarParam)

In introspection mode, the liftIO is a no-op, but needs to return a Bool. That seems unlikely (how to pick which?), but even if some defaulting is used, only one of foo or bar's info will be seen.

Worse, the bar property is not fully known until IO can be performed to get its parameter.

---

Another approach could be something like this:

withInfoFrom foo $ \callfoo ->
    withInfoFrom bar $ \callbar ->
        property "demo" = do
            needfoo <- liftIO checkFoo
            if needfoo
                then callfoo
                else callbar

Here withInfoFrom adds foo and bar as child properties of the demo property that (may) call them.

This approach is not fully type safe; it would be possible to call withInfoFrom in a way that didn't let it propagate the info.

And again this doesn't solve the problem that IO can be needed to get a parameter of a child property.

---

Another approach would be to add a new SimpleProperty, which is a property that has no Info. Only allow calling ensureProperty on this new type.

(Or, remove propertyInfo from Property, and add a new InfoProperty that has the info.)

But, propertyList can only contain one type at a time, not a mixed list of Property and SimpleProperty.

Could a GADT be used instead?

{-# LANGUAGE GADTs #-}
{-# LANGUAGE EmptyDataDecls #-}

data HasInfo
data NoInfo

data Property = IProperty (GProperty HasInfo) | SProperty (GProperty NoInfo)

data GProperty i where
    GIProperty :: Desc -> Propellor Result -> Info -> GProperty HasInfo
    GSProperty :: Desc -> Propellor Result -> GProperty NoInfo

ensureProperty :: GProperty NoInfo -> Propellor Result
ensureProperty (GSProperty d r) = r

That works. I made a gadtwip git branch that elaborated on that, to the point that Property.File compiles, but is otherwise unfinished. Most definitions of Property need to be changed to GProperty NoInfo, so that ensureProperty can call them. It's a big, intrusive change, and it may complicate propellor too much.

I've tried to make this change a couple times now, and not been completely successful so far.

(I may need to make instances of Prop for GProperty NoInfo and GProperty HasInfo, if that's possible, and make more Property combinators work on Prop.)