Testcase: linked-list

A common use for enums is to create a linked-list:

1. use List::*;

3. enum List {
4. // Cons: Tuple struct that wraps an element and a pointer to the next node
5. Cons(u32, Box<List>),
6. // Nil: A node that signifies the end of the linked list
7. Nil,
8. }

10. // Methods can be attached to an enum
11. impl List {
12. // Create an empty list
13. fn new() -> List {
14. // `Nil` has type `List`
15. Nil
16. }

18. // Consume a list, and return the same list with a new element at its front
19. fn prepend(self, elem: u32) -> List {
20. // `Cons` also has type List
21. Cons(elem, Box::new(self))
22. }

24. // Return the length of the list
25. fn len(&self) -> u32 {
26. // `self` has to be matched, because the behavior of this method
27. // depends on the variant of `self`
28. // `self` has type `&List`, and `*self` has type `List`, matching on a
29. // concrete type `T` is preferred over a match on a reference `&T`
30. match *self {
31. // Can't take ownership of the tail, because `self` is borrowed;
32. // instead take a reference to the tail
33. Cons(_, ref tail) => 1 + tail.len(),
34. // Base Case: An empty list has zero length
35. Nil => 0
36. }
37. }

39. // Return representation of the list as a (heap allocated) string
40. fn stringify(&self) -> String {
41. match *self {
42. Cons(head, ref tail) => {
43. // `format!` is similar to `print!`, but returns a heap
44. // allocated string instead of printing to the console
45. format!("{}, {}", head, tail.stringify())
46. },
47. Nil => {
48. format!("Nil")
49. },
50. }
51. }
52. }

54. fn main() {
55. // Create an empty linked list
56. let mut list = List::new();

58. // Prepend some elements
59. list = list.prepend(1);
60. list = list.prepend(2);
61. list = list.prepend(3);

63. // Show the final state of the list
64. println!("linked list has length: {}", list.len());
65. println!("{}", list.stringify());
66. }

See also:

Box and methods