Macro std::todo

macro_rules! todo {
    () => { ... };
    ($($arg:tt)+) => { ... };
}

Indicates unfinished code.

This can be useful if you are prototyping and just want a placeholder to let your code pass type analysis.

The difference between unimplemented! and todo! is that while todo! conveys an intent of implementing the functionality later and the message is “not yet implemented”, unimplemented! makes no such claims. Its message is “not implemented”. Also some IDEs will mark todo!s.

Panics

This will always panic!.

Examples

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

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 todo!:

struct MyStruct;

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

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

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

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