You may be in luck: http://smallcultfollowing.com/babysteps/blog/2014/09/30/mult...
Multidispatch traits are being implemented as we speak, and you are correct that this whole discussion is blocked on them (they are mentioned in the first RFC linked, the one discussing `FromError`).
Doesn't multiple dispatch require run-time type analysis? If so wouldn't that go against Rust's philosophy of zero-cost abstractions?
Re:On Error Handling in Rust
by carterschonwald on Thursday October 16, 2014 @11:52PM
(#8469356)
nope, its all compile time.
its just that instead of deciding which impl to pick based upon information X, youre using a pair of pieces of information (X,Y)
Edit, also I think the "convertable" class idea is nearly expressible using associated types in rust today,but im not 100% certain about that
Wikipedia implies that multiple dispatch is done by run-time time analysis in OO languages, which does not apply to Haskell or Rust: https://en.wikipedia.org/wiki/Multiple_dispatch
Maybe it's being pedantic, but I can't tell. Are Haskell's type classes strictly as flexible as multiple dispatch?
The proposed Rust feature sounds like overloading rather than multiple dispatch as it is usually understood.
I did this in Haskell using MPTC, I have used the Convertible class like:
instance Convertible IOError RedisError where safeConvert = <conversion mapping here>
Then I have combinators like:
convEither :: Convertible e1 e2 => Either e1 a -> Either e2 a
and
convEitherT :: Convertible e1 e2 => m (Either e1 a) -> EitherT m e2 a
These are quite handy in close quarters combat. For example to open a file and bail on a generic IOException with a custom application exception, I can have something like:
instance Convertible IOException CustomError
getWords :: FilePath -> IO (Either CustomError [String])
getWords fileName = runEitherT $