The enum type in Guide is not working

[chenyukang]

enum Ordering {
    Less,
    Equal,
    Greater,
}

fn cmp(a: int, b: int) -> Ordering {
    if a < b { Less }
    else if a > b { Greater }
    else { Equal }
}

fn main() {
    let x = 5i;
    let y = 10i;

    let ordering = cmp(x, y);

    if ordering == Less {
        println!("less");
    } else if ordering == Greater {
        println!("greater");
    } else if ordering == Equal {
        println!("equal");
    }
}

There error message is:

<anon>:21:8: 21:24 error: binary operation `==` cannot be applied to type `Ordering`
<anon>:21     if ordering == Less {
                 ^~~~~~~~~~~~~~~~
<anon>:23:15: 23:34 error: binary operation `==` cannot be applied to type `Ordering`
<anon>:23     } else if ordering == Greater {
                        ^~~~~~~~~~~~~~~~~~~
<anon>:25:15: 25:32 error: binary operation `==` cannot be applied to type `Ordering`
<anon>:25     } else if ordering == Equal {
                        ^~~~~~~~~~~~~~~~~
error: aborting due to 3 previous errors
playpen: application terminated with error code 101

[chenyukang]

shoud put #[deriving(PartialEq)] befre enum.

[garrickp]

The documentation at http://doc.rust-lang.org/guide.html#compound-data-types for the nightly build is still missing the note from chenyukang (which does work for me).

Docs are: Rust 0.13.0-nightly b87619e
Rust version is: rustc 0.13.0-nightly (b87619e 2014-11-02 23:27:10 +0000)

[bstrie]

Reopening because this is still broken, and for an especially pernicious reason. The guide automatically tests code examples by running each code snippet in isolation. The following snippet, as tested by the docs, is completely legal by itself:

fn cmp(a: int, b: int) -> Ordering {
    if a < b { Less }
    else if a > b { Greater }
    else { Equal }
}

fn main() {
    let x = 5i;
    let y = 10i;

    let ordering = cmp(x, y);

    if ordering == Less {
        println!("less");
    } else if ordering == Greater {
        println!("greater");
    } else if ordering == Equal {
        println!("equal");
    }
}

...however, if you do the sensible thing and concat the two separate code examples together, as a learner would expect, it suddenly fails to compile:

enum Ordering {
    Less,
    Equal,
    Greater,
}

fn cmp(a: int, b: int) -> Ordering {
    if a < b { Less }
    else if a > b { Greater }
    else { Equal }
}

fn main() {
    let x = 5i;
    let y = 10i;

    let ordering = cmp(x, y);

    if ordering == Less {  // error: binary operation `==` cannot be applied to type `Ordering`
        println!("less");
    } else if ordering == Greater {
        println!("greater");
    } else if ordering == Equal {
        println!("equal");
    }
}

This is because the Ordering enum here is really just a copy of the Ordering enum that is defined in the standard library and imported automatically by the prelude. So when you try the first code snippet, the one without the enum definition, it works by looking at the implicitly-imported variants. But when you define Ordering yourself, it shadows the existing variants, and because you don't have PartialEq derived it will fail inexplicably.

Someone remind me, why do we have Ordering in the prelude at all?

cc @steveklabnik

[steveklabnik]

Someone remind me, why do we have Ordering in the prelude at all?

This would be a pretty elegant answer to this problem. I love shadowing in general, but it causes problems in situations like these.

[evangoer]

Ran into this as well for the reason @bstrie outlined (as have some other people, based on previously closed issues).

What about showing the reader how to create & use their own enum? That's how the previous sections on tuples & structs worked.

[ftxqxd]

The Guide doesn’t explicitly say to try running that portion of code (although it is very easy to make that mistake): it says that Ordering is ‘provided by the Rust standard library’. I think that this could be made clearer by simply expanding on and emphasising the fact that defining it yourself will not necessarily work (e.g., ‘This is an enum that is provided by the Rust standard library, with a few extra bits added to let things like == work’).

[ariddell]

When I read it, I got the sense that the code should run. I think mentioning that the code will not run as written (in contrast to many of the other snippets) would be a good idea.

[anuj-sahai]

I got stuck here for a while too. I missed the part about it being in Rust standard library and was quite confused about why OptionalInt enum requires the namespace prefix later in the doc. but Ordering didn't and assumed it might be implicit and that namespaces are optional.

Only after I tried the Ordering example and got the following error did I realize that namspace is a must. The example in the original post above does work if enum values are prefixed with namespace.

ordering.rs:8:16: 8:20 error: mismatched types: expected `Ordering`, found `core::cmp::Ordering` (expected enum Ordering, found enum core::cmp::Ordering)
ordering.rs:8     if a < b { Less }
                             ^~~~