I've been playing with this, and it seems rather nasty to avoid nasty recursive type definitions.  Suppose we have a type `FooFFT{T,true} <: Plan{T}` that computes FFTs, and that the inverse is of a slightly different type `FooFFT{T,false}`.  I want to put a correctly typed `pinv` field in it (initially undefined) like this:
```
type FooFFT{T,forward} 
    pinv::FooFFT{T,!forward}
    FooFFT() = new()
end
```
But this isn't allowed (`no method !(TypeVar)`).  So, instead, I parameterize by the type of `pinv`:
```
type FooFFT{T,forward,P} <: Plan{T}
    pinv::P
    FooFFT() = new()
end
```
But then my initialization requires an infinitely recursive type:
```
FooFFT{T,true,FooFFT{T,false,FooFFT{T,true,...}}}()
```
One compromise would be to initialize it as 
```
FooFFT{T,true,FooFFT{T,false,Plan{T}}}()
```
which means that `inv(inv(p))` would not have a type that is detectable by the compiler.

Is there a better way?