diff --git a/.gitignore b/.gitignore
index de87c1e7..6094e5c1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ target/
 *.pdb
 exercises/clippy/Cargo.toml
 exercises/clippy/Cargo.lock
+.idea
diff --git a/exercises/quiz3.rs b/exercises/quiz3.rs
index bc9b8e55..ec86a8e5 100644
--- a/exercises/quiz3.rs
+++ b/exercises/quiz3.rs
@@ -1,4 +1,4 @@
-// quiz.rs
+// quiz3.rs
 // This is a quiz for the following sections:
 // - Tests
 
diff --git a/exercises/standard_library_types/README.md b/exercises/standard_library_types/README.md
index d138d874..36b30c1f 100644
--- a/exercises/standard_library_types/README.md
+++ b/exercises/standard_library_types/README.md
@@ -1,3 +1,5 @@
+For the Box exercise check out the chapter [Using Box to Point to Data on the Heap](https://doc.rust-lang.org/book/ch15-01-box.html).
+
 For the Arc exercise check out the chapter [Shared-State Concurrency](https://doc.rust-lang.org/book/ch16-03-shared-state.html) of the Rust Book.
 
 For the Iterator exercise check out the chapters [Iterator](https://doc.rust-lang.org/book/ch13-02-iterators.html) of the Rust Book and the [Iterator documentation](https://doc.rust-lang.org/stable/std/iter/).
diff --git a/exercises/standard_library_types/box1.rs b/exercises/standard_library_types/box1.rs
new file mode 100644
index 00000000..2248962e
--- /dev/null
+++ b/exercises/standard_library_types/box1.rs
@@ -0,0 +1,53 @@
+// box1.rs
+//
+// 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`.
+//
+// Step 1: use a `Box` in the enum definition to make the code compile
+// Step 2: create both empty and non-empty cons lists of by replacing `unimplemented!()`
+//
+// Note: the tests should not be changed
+//
+// Execute `rustlings hint box1` for hints :)
+
+// I AM NOT DONE
+
+#[derive(PartialEq, Debug)]
+pub enum List {
+    Cons(i32, 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());
+}
+
+pub fn create_empty_list() -> List {
+    unimplemented!()
+}
+
+pub fn create_non_empty_list() -> List {
+    unimplemented!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_empty_list() {
+        assert_eq!(List::Nil, create_empty_list())
+    }
+
+    #[test]
+    fn test_create_non_empty_list() {
+        assert_ne!(create_empty_list(), create_non_empty_list())
+    }
+}
diff --git a/exercises/traits/README.md b/exercises/traits/README.md
new file mode 100644
index 00000000..1ce46fe0
--- /dev/null
+++ b/exercises/traits/README.md
@@ -0,0 +1,20 @@
+### Traits
+
+A trait is a collection of methods. 
+
+Data types can implement traits. To do so, the methods making up the trait are defined for the data type. For example, the `String` data type implements the `From<&str>` trait. This allows a user to write `String::from("hello")`.
+
+In this way, traits are somewhat similar to Java interfaces and C++ abstract classes.
+
+Some additional common Rust traits include:
+
++ `Clone` (the `clone` method), 
++ `Display` (which allows formatted display via `{}`), and
++ `Debug` (which allows formatted display via `{:?}`).
+
+Because traits indicate shared behavior between data types, they are useful when writing generics.
+
+
+#### Book Sections
+
+- [Traits](https://doc.rust-lang.org/book/ch10-02-traits.html)
\ No newline at end of file
diff --git a/exercises/variables/variables6.rs b/exercises/variables/variables6.rs
index 8407754b..b4bed965 100644
--- a/exercises/variables/variables6.rs
+++ b/exercises/variables/variables6.rs
@@ -1,4 +1,4 @@
-// variables5.rs
+// variables6.rs
 // Make me compile! Execute the command `rustlings hint variables6` if you want a hint :)
 
 const NUMBER: u8 = 3;
diff --git a/info.toml b/info.toml
index 66d60da2..2c871ad2 100644
--- a/info.toml
+++ b/info.toml
@@ -311,7 +311,7 @@ hint = "No hints this time ;)"
 # TESTS
 
 [[exercises]]
-name = "quiz1"
+name = "tests1"
 path = "exercises/tests/tests1.rs"
 mode = "test"
 hint = """
@@ -614,6 +614,24 @@ hint = """
 
 # STANDARD LIBRARY TYPES
 
+[[exercises]]
+name = "box1"
+path = "exercises/standard_library_types/box1.rs"
+mode = "test"
+hint = """
+Step 1
+The compiler's message should help: since we cannot store the value of the actual type
+when working with recursive types, we need to store a reference (pointer) to its value.
+We should, therefore, place our `List` inside a `Box`. More details in the book here:
+https://doc.rust-lang.org/book/ch15-01-box.html#enabling-recursive-types-with-boxes
+
+Step 2
+Creating an empty list should be fairly straightforward (hint: peek at the assertions).
+For a non-empty list keep in mind that we want to use our Cons "list builder".
+Although the current list is one of integers (i32), feel free to change the definition
+and try other types!
+"""
+
 [[exercises]]
 name = "arc1"
 path = "exercises/standard_library_types/arc1.rs"