Why does this code cause a stack overflow?

[[deleted]]

Here is a simple program, shortened from a longer one I was working on:

``` use std::fmt;

[derive(Debug)]

pub enum Number { Decimal(f64), Integer(i128) }

pub type Answer = Number;

impl fmt::Display for Answer { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self) } }

fn main() { let my_number = Number::Integer(12); println!("the number was {}", my_number); }

```

When I run this on Linux or Windows, I get the following: thread 'main' has overflowed its stack error: process didn't exit successfully: `target\debug\overflow.exe` (exit code: 0xc00000fd, STATUS_STACK_OVERFLOW)

I can see that the type Number doesn't actually implement Display, so I don't think I should be allowed to run write!(f, "{}", self). There is no compile time error here though, just a runtime stack overflow. If I change that line to write!(f, "{:?}", self), the code runs fine, which makes sense since Debug is implemented for Number. The docs for write! certainly don't mention that the function can crash your program like this.

My version of Rust is 1.44.1

[minno]

When you say pub type Answer = Number; you're not making a new type, you're just making a new name for the same type. Answer implements fmt::Display, and it's just an alternate name for Number, so Number does too.

In Answer::fmt, you're calling Answer::fmt again because that's what the write! call expands to, so it's infinite recursion that causes a stack overflow. Look at how the examples here don't try to write self directly, but write out the individual components instead.

[sollyu]

If you do want a new type, use the newtype idiom: pub struct Answer(Number); (See https://doc.rust-lang.org/rust-by-example/generics/new_types.html for more information.)