为什么Rust有struct和enum？

Question

Rust's enums are algebraic datatypes. As far as I can tell this seems to subsume what struct is. What is different about struct that necessitates keeping it?

Answer 1

First of all, you are correct that semantically enum is strictly superior to the struct as to what it can represent, and therefore struct is somewhat redundant.

However, there are other elements at play here.

• ease of use: the values within an enum can only be accessed (directly) through matching; contrast with the ease of use of accessing a struct field. You could write accessors for each and every field, but that is really cumbersome.

• distinction: an enum is a tagged union, a struct has a fixed-layout; we (programmers) generally like to put labels on things, and therefore giving different names to different functionality can be appreciated.

As I see it, struct is therefore syntactic sugar. I usually prefer lean and mean, but a bit of sugar can go a long way in increasing what can be represented tersely.

Answer 2

Firstly, Rust has a wide array of data types:

• Structs with named fields ( struct Foo {bar: uint} )
• Tuple structs ( struct Foo(pub Bar, Baz) )
• Structs with no fields ( struct Foo; )
• Enums, with various types of variants:
  • Variants with no fields (eg None )
  • Tuple variants (eg Some(T) )
  • Struct variants (eg Some { pub inner :T } )

This gives the programmer some flexibility in defining datatypes. Often, you don't want named fields, especially if the struct/variant has only one field. Rust lets you use tuple structs/tuple variants in that case.

If structs were removed from Rust there would be no loss of functionality, enums with struct variants could be used again. But there would be an overwhelming number of single-variant enums which would be unnecessary and cumbersome to use.

Answer 3

Not 100% correct, but another nice way to think about it : enum isn't actually superior to struct , the syntax sugar just makes it look like it is.

An enum is a sum type meaning that it's value is one value of one of a set of other types. The Result<T, E> type is either of type T or E . So each enum variant has exactly one type associated with it. Everything else (no type, tuple variants and struct variants) could be syntax sugar.

enum Animal {
    // without syntax sugar
    Cat(i32),  
    // desugars to `Dog(())` (empty tuple/unit) 
    Dog,
    // desugars to `Horse((i32, bool))` (tuple)
    Horse(i32, bool),
    // desugars to `Eagle(GeneratedEagleType)` and a struct definition outside
    // of this enum `struct GeneratedEagleType { weight: i32, male: bool }`
    Eagle { weight: i32, male: bool }
}

So it would be enough if each enum variant would be associated with exactly one type. And in that case enum is not superior to struct , because it cannot construct product types (like struct ).

To be able write the "type definition" inside the enum variant definition is just for convenience.

Also: struct is superior to "tuple structs" and "tuples", too. If we ignore the names those three things are nearly equivalent. But Rust still has those three different kinds of types for convenience.

---

Please note that I don't know if those enum definitions are actually syntax sugar or not. But they could be and that might help think about. it

Answer 4

Visibility

Not to find reason in what may be a transient implementation detail (I'm not on the core team and have no insight), but

• A public enum can not hold or contain a private struct.
• A public struct can hold or contain a private enum.

See also

• Why does "can't leak private type" only apply to structs and not enums?

Answer 5

You are right that enums and traits and their inheritance by structs both implement algebraic datatypes.

However traits is an extensible set of types, where any stuct can be attributed any trait from any piece of code. Using introspection, it is possible to expect a value with a given trait, and dynamically dig out the actual type of a struct. But that type is among a set of types that is unpredictable, because any struct could be given the said trait from anywhere.

Whereas enums define once and for all a limited type hierarchy, making it predictable and straightforward to go match subtypes as if they were simple values. The language features surrounding enums can therefore be optimized so that the type checks occur statically, providing much greater performance, and some sugar in the language. But also the hierarchy description is contained to the enum definition, and does not impact the trait type system.

TL;DR: enum narrows down a hierarchy of types in a contained manner, instead of relying on traits that are extensible by any piece of code and impacts everything.

Answer 6

Another important distinction along with the above answers is that enum at one point can ONLY be one of the values stated while struct represents values for all the parameters for that instance. eg.

enum Things{
Box, 
Page(i32),
}

struct Things{
box: Option<String>,
page: i32,
}

In the above case a single enum can either be a Box or a Page, while a single instance of struct will represent a box and a page.