# 1.0.0[−][src]Trait std::marker::Sized

    #[lang = "sized"]
    pub trait Sized { }

Types with a constant size known at compile time.

All type parameters have an implicit bound of `Sized`. The special syntax `?Sized` can be used to remove this bound if it's not appropriate.

    struct Foo<T>(T);
    struct Bar<T: ?Sized>(T);

    // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]
    struct BarUse(Bar<[i32]>); // OKRun

The one exception is the implicit `Self` type of a trait. A trait does not have an implicit `Sized` bound as this is incompatible with trait objects where, by definition, the trait needs to work with all possible implementors, and thus could be any size.

Although Rust will let you bind `Sized` to a trait, you won't be able to use it to form a trait object later:

    trait Foo { }
    trait Bar: Sized { }

    struct Impl;
    impl Foo for Impl { }
    impl Bar for Impl { }

    let x: &Foo = &Impl;    // OK
    // let y: &Bar = &Impl; // error: the trait `Bar` cannot
                            // be made into an objectRun

## Implementors

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)