Unexpected productivity boost of Rust

Though it's not the only benefit, I enjoy rust and fsharp's typesystems most when refactoring code. Fearless refactoring is the right expression here.

The only issue with it is that Rust's aversion to half-baked code means that you can't have "partially working code" during the refactor: you either finish it or bail on it, without the possibility to have inconsistent codebase state. This is particularly annoying for exploratory code.

On the other hand, that strictness is precisely what leads people to end up with generally reasonable code.

I find a healthy dose of todo!() is excellent for this.

    match foo {
      (3...=5, x, BLABLABLA) => easy(x),
      _ => todo!("I should actually implement this for non-trivial cases"),
    }

The nice thing about todo!() is that it type checks, obviously it always diverges so the type match is trivial, but it means this compiles and, so long as we don't cause the non-trivial case to happen, it even works at runtime.

The thing is I want an equivalent to `todo!()` for the type-system. A mode of operation where if you have some compile errors, you can still run tests. Like for example, if you have

    fn foo() -> impl Display {
        NotDisplay::new()
    }

and a test references `foo`, then it gets replaced for the purposes of the test with

    fn foo() -> impl Display {
        panic!("`NotDisplay` doesn't `impl Display`")
    }

This should not be part of the language, but part of the toolchain.

Same thing for the borrow-checker.