The difference is that the author's suggestion as to what to do instead doesn't work in Rust. In Haskell there's no need to use a type class/trait here at all; you can just use a record. We could try to do the same thing in Rust with a struct:
struct EventHandler {
handle_start_event: fn(),
handle_completion_event: fn(),
}
...but this differs in a key way from the haskell example:
Rust's `fn` is not a closure, it's just a pointer to some code, and you can't construct them dynamically. If you want to pass around a _closure_, you need ...a trait object.
Something like:
struct EventHandler {
handle_start_event: Box<dyn impl Fn()>,
handle_start_event: Box<dyn impl Fn()>,
}
...but that's exactly the pattern the author of that post is suggesting getting away from.
I agree with the author's point, but it doesn't really apply to Rust because there isn't actually a simpler way to do it. And I think that's part of what the OP was getting at -- Trait objects are the closest thing Rust has to proper closures, and they're a bit awkward.
Note that I'm still something of a newbie at Rust, and don't feel like I can really say much about the day to day experience of using (or avoiding) trait objects due to limited experience.