let's not try to get outertarget from monad

To get outertarget from the Propellor monad, the monad would have to be
parameteriszed with an outertarget type, since there's no single type.

For example:

newtype Propellor target p = Propellor { runWithHost :: RWST target () () IO p }
        deriving (Monad, Applicative, Functor)

But then mkProperty becomes a problem, since the Propellor action
passed to it needs to already be of UnixLike type:

mkProperty :: Propellor UnixLike () -> Property UnixLike
mkProperty a = Property unixLike a

Could maybe live with that, but then `target` type check fails:

    Expected type: Propellor (Targeting combinedtarget) ()
      Actual type: Propellor (Targeting oldtarget) ()

Problem being that it's reusing the `a` which is a Propellor target ()

  target newtarget (Property oldtarget a) = Property (intersectTarget oldtarget newtarget) a

And, the new Property has a different target, so it can't use the old `a`.

So, I'd need a way to cast one Propellor target () to a different target.

Maybe:

target newtarget (Property oldtarget (Propellor a)) =
        let combinedtarget = intersectTarget oldtarget newtarget
        in Property combinedtarget (Propellor (unsafeCoerce a))

But is that safe??

Even if it is, I can't see how to make ensureProperty get the outertarget
type. It returns Propellor (Targeting outertarget) (), which can read
the target from the RWST monad, but how to use that where the type of the
function is defined?

Rather than all that complication, it doesn't seem too bad to
require outertarget be passed to ensureProperty.

0 files changed, 0 insertions, 0 deletions