Custom data types which accept only values enumerated by programmer.

[jesseray]

In Haskell (using GHC), you can write

data Tanks = 0 | 1 | 2 | 3 | 4

to define a new data type called Tanks that can have the value 0 or 1 or 2 or 3 or 4. When you define a variable of type Tanks, you must define it as having one of the values enumerated in the data type definition. If you try to use a value that is not enumerated in the data type definition, such as 5,

hearts :: Tanks
hearts = 5

the compiler will abandon compilation and display an error message that says (in essence) that the value is not acceptable.

By defining new data types that accept the enumerated values and no others, module developers can prevent other programmers from abusing their modules because the abuses will cause compiler errors. In this way, module developers increase the chances that, if the code compiles, the code works correctly.

Rust does not support this without workarounds.

A programmer could try to use an Enum, but these enumerate constructors with valid Rust identifiers, not values. As such, the programmer would need to define constructors to use as placeholders for each of the values they want enumerated. That would fill their modules with boilerplate code and make them unpleasant for other programmers to use. Hence, I do not consider this workaround viable.

The programmer could use a Struct with a private field and a Setter method which prevents the field from being given a value that the module developer does not want. This workaround involves much less boilerplate and the module remains pleasant for other programmers to work with. Hence, I do consider this workaround viable. Even so, when compared with the Haskell approach, it strikes me as avoidably ugly, because Haskell does not require any boilerplate code at all.

Can the Rust language and compiler be extended to allow programmers to define new data types that can have only the values enumerated by the programmer, but without boilerplate code?

[glaebhoerl]

In Haskell (using GHC), you can write

data Tanks = 0 | 1 | 2 | 3 | 4

Huh? Not with my GHC.

[jesseray]

You are right. I was misled by Making Our Own Types and Typeclasses, which says:

In a similar fashion, we can think of the Int type as being defined like this:

    data Int = -2147483648 | -2147483647 | ... | -1 | 0 | 1 | 2 | ... | 2147483647

That is false. According to The Haskell 98 Report, Section 4.2, the components to the right of the equal sign must be data constructors, not values. It turns out that we cannot think of the Int type as being defined that way. I hate when people teach a subject using falsehoods... (sigh)

In any case, I still think it would be a nice feature to have.

[catamorphism]

Also see #1679 (a similar idea, though not quite the same).

[glaebhoerl]

@jesseray, you define a datatype by enumerating its constructors, but then those constructors are the values of that type. If I write data Foo = A | B | C, then the values of type Foo are A, B, and C. The analogy being made here is similar: 0, 1, 2 etc. can be thought of as constructors for the type Int, and hence its possible values. So when we write data Int = ... | -1 | 0 | 1 | 2 | ..., these are not already-existing values which we are referring to, rather we are bringing them into existence with our definition. (If this were valid syntax, which of course it's not.)

(The analogy does break down if you consider that 1, 2, 3 etc. are also values of type Integer, Int8, Int16, Int32, Word8 etc. which are all distinct types (numeric literals are in fact polymorphic), but it kind of works if you pretend that only Int exists.)

[emberian]

Visiting for triage. I don't think this is important.

[Aatch]

If anybody is still interested in this, an official RFC should be filed. https://github.com/rust-lang/rfcs/blob/master/active/0001-rfc-process.md