Is `WithSimd` still necessary?

[valadaptive]

I'm starting to look at the API surface, and I'm now wondering if WithSimd gives us anything that the dispatch! macro doesn't. The one method that actually makes use of WithSimd, Level.dispatch, just defers to the dispatch! macro internally anyway:

    pub fn dispatch<W: WithSimd>(self, f: W) -> W::Output {
        dispatch!(self, simd => f.with_simd(simd))
    }

I thought it might be useful for adding extra type parameters to dispatched function calls or something, but it appears to be equivalent in power to dispatch! while being a lot more annoying to use. Should we just remove WithSimd?

[DJMcNab]

In theory, it can be used for calling an operation which is generic over the SIMD type, without an intermediate "convert to Level then dispatch" operation. Effectively, it's the vectorised version of FnOnce (but without any syntax sugar, of course).

However, I've not seen any evidence of it actually being used for that, and the question becomes "how much cost does that indirection add" isn't one I have a quick answer for. My intuition is that LLVM will constant fold it away almost trivially. I can imagine a compile time cost (it's theoretically O(n^2) in the number of supported backends, but the constant factor is extremely low, as is the N).
I wouldn't be opposed to just removing it entirely. That seems easier than cleaning up the docs.