What does “Sized is not implemented” mean?

by

The Sized trait is rather special, so special that it is a default bound on type parameters in most situations. It represents values that have a fixed size known at compile time, like u8 (1 byte) or &u32 (8 bytes on a platform with 64-bit pointers) etc. These values are flexible: they can be placed on the stack and moved onto the heap, and generally passed around by-value, as the compiler knows how much space it needs where-ever the value goes.

Types that aren’t sized are much more restricted, and a value of type Writer isn’t sized: it represents, abstractly, some unspecified type that implements Writer, with no knowledge of what the actual type is. Since the actual type isn’t known, the size can’t be known: some large types are Writers, some small types are. Writer is one example of a trait object, which at the moment, can only appear in executed code behind a pointer. Common examples include &Writer, &mut Writer, or Box<Writer>.

This explains why Sized is the default: it is often what one wants.

In any case, for your code, this is popping up because you’re using handle with h, which is a Fn(&mut Writer) -> IoResult<()>. If we match this against the F: Fn(&mut W) -> IoResult<()> type that Handle is implemented for we find that W = Writer, that is, we’re trying to use handle with the trait object &mut Writer, not a &mut W for some concrete type W. This is illegal because the W parameters in both the trait and the impl are defaulting to have a Sized bound, if we manually override it with ?Sized then everything works fine:

use std::io::{IoResult, Writer};
use std::io::stdio;

fn main() {
    let h = |&: w: &mut Writer| -> IoResult<()> {
        writeln!(w, "foo")
    };
    let _ = h.handle(&mut stdio::stdout());
}

trait Handler<W: ?Sized> where W: Writer {
    fn handle(&self, &mut W) -> IoResult<()>;
}

impl<W: ?Sized, F> Handler<W> for F
where W: Writer, F: Fn(&mut W) -> IoResult<()> {
    fn handle(&self, w: &mut W) -> IoResult<()> { (*self)(w) }
}

And for the Rust 1.0 code:

use std::io::{self, Write};

fn main() {
    handle(&mut io::stdout());
}

fn handle(w: &mut Write) -> io::Result<()> {
    handler(w)
}

fn handler<W: ?Sized>(w: &mut W) -> io::Result<()>
where
    W: Write,
{
    writeln!(w, "foo")
}

I also wrote a blog post about Sized and trait objects in general which has a little more detail.

More Related Contents:

  1. How do I create a heterogeneous collection of objects?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. Is it possible to control the size of an array using the type parameter of a generic?
  4. How to transform fields during deserialization using Serde?
  5. Temporarily move out of borrowed content
  6. Need holistic explanation about Rust’s cell and reference counted types
  7. Sending trait objects between threads in Rust
  8. Error while trying to borrow 2 fields from a struct wrapped in RefCell
  9. Why would I implement methods on a trait instead of as part of the trait?
  10. How to initialize struct fields which reference each other
  11. What does “mismatched types: expected `()`” mean when using an if expression?
  12. How can I downcast from Box to a trait object type?
  13. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  14. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  15. Using generic trait methods like .into() when type inference is impossible
  16. Why does an enum require extra memory size?
  17. What is a crate attribute and where do I add it?
  18. Parameter type may not live long enough?
  19. Why does Rust disallow mutable aliasing?
  20. How to store rusqlite Connection and Statement objects in the same struct in Rust? [duplicate]
  21. How to model complex recursive data structures (graphs)?
  22. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  23. How do I specify the linker path in Rust?
  24. How can I override a constant via a compiler option?
  25. Why am I getting “parameter is never used [E0392]”?
  26. Creating a vector of zeros for a specific size
  27. What is the difference between immutable and const variables in Rust?
  28. How do I create a HashMap with type erased keys?
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment