Enumerations

In C++ an enum is a bunch of labels assigned an int value. i.e. it is basically a bunch of constants with scalar values.

  1. enum HttpResponse {
  2.   okay = 200,
  3.   not_found = 404,
  4.   internal_error = 500,
  5. };

C++11 extends this concept a little, allowing you to declare an enum that uses another kind of integral type, e.g. a char to hold the values.

  1. enum LibraryCode : char {
  2.   checked_in = 'I',
  3.   checked_out = 'O',
  4.   checked_out_late = 'L'
  5. };

In Rust an enum can be a scalar value just like in C++. 

  1. enum HttpResponse {
  2.   Ok= 200,
  3.   NotFound= 404,
  4.   InternalError = 500
  5. };

But an enum can also hold actual data so you can convey far more information than a static value could by itself. 

  1. enum HttpResponse {
  2.   Ok,
  3.   NotFound(String),
  4.   InternalError(String, String, Vec<u8>)
  5. }

You can also bind functions to the enum:

  1. impl HttpResponse {
  2.   pub fn code(&self) => {
  3.     match *self {
  4.       HttpResponse::Ok => 200,
  5.       HttpResponse::NotFound(_) => 404,
  6.       HttpResponse::InternalError(_, _, _) => 500,
  7.     }
  8.   }
  9. }

So we might have a function that makes an http request and returns a response:

  1. fn do_request(url: &str) -> HttpResponse {
  2.   if url == "/invalid" {
  3.     HttpResponse::NotFound(url.to_string())
  4.   }
  5.   else {
  6.     HttpResponse::Ok
  7.   }
  8. }
  9. //...
  10. let result = do_request("/invalid");
  11. if let HttpResponse::NotFound(url) = result {
  12.   println!("The url {} could not be found", url);
  13. }

Now our code is able to return a more meaningful response in an enum and the code is able to extract that response to print out useful information.