// At compile time, Rust needs to know how much space a type takes up. This // becomes problematic for recursive types, where a value can have as part of // itself another value of the same type. To get around the issue, we can use a // `Box` - a smart pointer used to store data on the heap, which also allows us // to wrap a recursive type. // // The recursive type we're implementing in this exercise is the "cons list", a // data structure frequently found in functional programming languages. Each // item in a cons list contains two elements: The value of the current item and // the next item. The last item is a value called `Nil`. #[derive(PartialEq, Debug)] enum List { Cons(i32, Box<List>), Nil, } fn create_empty_list() -> List { List::Nil } fn create_non_empty_list() -> List { List::Cons(42, Box::new(List::Nil)) } fn main() { println!("This is an empty cons list: {:?}", create_empty_list()); println!( "This is a non-empty cons list: {:?}", create_non_empty_list(), ); } #[cfg(test)] mod tests { use super::*; #[test] fn test_create_empty_list() { assert_eq!(create_empty_list(), List::Nil); } #[test] fn test_create_non_empty_list() { assert_ne!(create_empty_list(), create_non_empty_list()); } }