# core::unimplemented! [−] [src]

    macro_rules! unimplemented {
        () => { ... };
    }

A standardized placeholder for marking unfinished code. It panics with the message `"not yet implemented"` when executed.

This can be useful if you are prototyping and are just looking to have your code typecheck, or if you're implementing a trait that requires multiple methods, and you're only planning on using one of them.

# Examples

Here's an example of some in-progress code. We have a trait `Foo`:

fn main() { trait Foo { fn bar(&self); fn baz(&self); } }

    trait Foo {
        fn bar(&self);
        fn baz(&self);
    }

We want to implement `Foo` on one of our types, but we also want to work on just `bar()` first. In order for our code to compile, we need to implement `baz()`, so we can use `unimplemented!`:

trait Foo { fn bar(&self); fn baz(&self); } struct MyStruct; impl Foo for MyStruct { fn bar(&self) { // implementation goes here } fn baz(&self) { // let's not worry about implementing baz() for now unimplemented!(); } } fn main() { let s = MyStruct; s.bar(); // we aren't even using baz() yet, so this is fine. }

    struct MyStruct;

    impl Foo for MyStruct {
        fn bar(&self) {
            // implementation goes here
        }

        fn baz(&self) {
            // let's not worry about implementing baz() for now
            unimplemented!();
        }
    }

    fn main() {
        let s = MyStruct;
        s.bar();

        // we aren't even using baz() yet, so this is fine.
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## 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`)