Now compiles as far back as GHC 7.0
Several renamings; 'couple' -> 'resource';

 * The monad transformer formerly known as 'CoupleT' is now known as 'Resource'. This is inspired by Gabriel Gonzales's post [The Resource Monad](http://www.haskellforall.com/2013/06/the-resource-applicative.html), which describes a similar constrcut.
 * Accordingly, 'couple' has been renamed to 'resource', and 'decouple' has been renamed to 'acquire'.
 * The 'Resource' monad now lives in the module 'Data.Resource', as opposed to the longer 'Control.Monad.Trans.Couple'.
 * The 'DecoupleT' monad transformer has also been renamed, again inspired by Gabriel Gonzales. The [pipes-safe](http://hackage.haskell.org/package/pipes-safe) package has a very similar monad, which is also called 'SafeT'.

After renaming everything in this package several times, I think these names will be final. 'Resource' was always the obvious name for that monad, but I hesitated to call it Resource(T) because "ResourceT" is already used by Michael Snoyman for a monad similar to "SafeT", for which I also struggled to find a good name.
Tweaked import style for type classes.
Renamed 'withFork' to 'forkWith'; removed 'withForkOn'.
Moved 'unsafeAcquire' from "Data.Resource.Unsafe" to "Control.Monad.Interface.Safe".

It's a bit of a toss-up to figure out where to put this operation (and the package is definitely incomplete without it), but given as it isn't actually unsafe (as in, it doesn't do anything not allowed by Safe Haskell), I figured it was easier just to put it in "Control.Monad.Interface.Safe", especially as that's where "acquire" lives.
Replaced 'acquire' with 'register' in the 'MonadSafe' interface. 'acquire' is now implemented in terms of 'register'.
Added 'ReleaseKey' abstract data type and 'release' operation.

This is a bit more flexible, and is in line with similar implementations (Michael Snoyman's 'ResourceT' and Gabriel Gonzales' 'SafeT').

Our 'ReleaseKey' however is not really a "key" at all, but I couldn't think of a better name, and at least this one is consistent with other packages.
Renamed "Control.Monad.Interface.Safe.ReleaseKey" to "Control.Monad.Interface.Safe.Internal", and moved MonadSafe and associated operations there.

The nice thing is about this is that the SafeT part of the package and the Resource part of the package are almost completely separate from each other. All the glue between them is contained in the "Control.Monad.Interface.Safe" module (which also re-exports some of "Control.Monad.Interface.Safe.Internal"). In fact that is the only thing that module contains.
Renamed 'Finalizers' to 'ReleaseMap' in "Control.Monad.Trans.Safe".

I'm not sure where I picked up the 'Finalizers' name from, but the my original 'ResourceT' implementation called it 'ReleaseMap', which I think is a much more descriptive name, and is no longer.
Added 'register'' and 'release'' operations to the 'MonadSafe' interface, as well as the 'resource'' constructor for 'Resource'.

It is now possible to specify that a different finalizer be run if the main code threw an exception as opposed to finishing successfully. This is useful in some instances, and makes it possible to model a 'ForeignPtr' as a 'Resource', for example. The behaviour of the non-primed versions of the above operations remains unchanged.
Cleaned up some unnecessary uses of 'mask'/'restore' in the implementation of the 'Resource' monad.

This does change the behaviour slightly in some corner cases, but the new behaviour is actually probably better, and is in line with how 'bracket' behaves.
Changed the names of some one-letter variables.
Added 'cancel' operation for 'ReleaseKey's.

This allows an action that has been 'register'ed with a 'MonadSafe' to be cancelled before the end of computation.
Added analogues of the 'MonadTry' operations to the 'MonadSafe' interface.

The difference between these operations and the 'MonadTry' ones is that the finalisers are run even in the case of premature termination (e.g., when using the @pipes@ library).
Removed 'unsafeAcquire' from "Control.Monad.Interface.Safe", which also allows us to get rid of the 'resource'' operation.

Instead I now just export the constructor for the 'Resource' type from "Data.Resource", which effectively does the same thing. This also now means that "Data.Resource" exports everything (constructors and all) that "Data.Resource.Internal" does (and also that "Control.Monad.Interface.Safe" exports everything "Control.Monad.Interface.Safe.Internal" does), so the "Internal" modules aren't really internal anymore. However, I keep them around because it allows us re-export relevant bits of "Data.Resource" from "Control.Monad.Interface.Safe" and vice-versa without creating circular (and unnecessary - these re-exports are only for convenience) dependencies between them. As I say below, I don't think either the 'Resource' part or the 'SafeT'/'MonadSafe' part of the library is really complete without the glue between them (i.e., 'acquire'), so for that reason it's important that 'acquire' gets re-exported from both parts of the library.

This also further decouples the 'SafeT'/'MonadSafe' part of the library from the 'Resource' part. In fact, they could be packaged entirely separately now, and I'm tempted to do so, but I will leave it for now. 'acquire' is the only glue between them as it stands, so it would be possible to put it in either the 'Resource' or 'SafeT'/'MonadSafe' part of this hypothetical split (thus making one half dependent on the either, albeit just for 'acquire'), however, I don't think either half of the library would be complete without 'acquire', and it doesn't belong to one more than the other. So I'll keep things as they are.
Added 'Finalizers' datatype to simplify the implementation of 'Resource'.

This in some way undoes some of the uncoupling achieved in the previous commit, but in other ways furthers it. It would still be possible to split the 'Resource' and 'SafeT'/'MonadSafe' parts, but now the latter would be firmly dependent on the former. But that's okay, it actually makes things simpler, and it means there is an obvious place to put the "glue": in the 'SafeT'/'MonadSafe' part.

The 'Finalizers' datatype makes several things explicit that were probably not clear before (the code is still mostly undocumentated). I think it also satisfactorily solves the 'unsafeAcquire' problem, such that the 'Resource' part of the library would actually be a viable library in its own right (even without the 'acquire' operation from the 'MonadSafe' interface). However I'm still going to keep them together.
Added 'Data.Resource.Base', a module which contains 'Resource's for all the `with-` idioms in the `base` package.