diff --git a/README b/README
index 90003fd..f6377ce 100644
--- a/README
+++ b/README
@@ -8,81 +8,83 @@ be saved to and loaded from a file (or any io.Reader/Writer) to recover from
 downtime quickly.
 
 == Installation
-    goinstall github.com/pmylund/go-cache
+
+goinstall github.com/pmylund/go-cache
 
 == Usage
-    import "github.com/pmylund/go-cache"
 
-    // Create a cache with a default expiration time of 5 minutes, and which
-    // purges expired items every 30 seconds
-    c := cache.New(5*time.Minute, 30*time.Second)
+import "github.com/pmylund/go-cache"
 
-    // Set the value of the key "foo" to "bar", with the default expiration time
-    c.Set("foo", "bar", 0)
+// Create a cache with a default expiration time of 5 minutes, and which
+// purges expired items every 30 seconds
+c := cache.New(5*time.Minute, 30*time.Second)
 
-    // Set the value of the key "baz" to "yes", with no expiration time
-    // (the item won't be removed until it is re-set, or removed using
-    // c.Delete("baz")
-    c.Set("baz", "yes", -1)
+// Set the value of the key "foo" to "bar", with the default expiration time
+c.Set("foo", "bar", 0)
 
-    // Get the string associated with the key "foo" from the cache
-    foo, found := c.Get("foo")
-    if found {
-            fmt.Println(foo)
-    }
+// Set the value of the key "baz" to "yes", with no expiration time
+// (the item won't be removed until it is re-set, or removed using
+// c.Delete("baz")
+c.Set("baz", "yes", -1)
 
-    // Since Go is statically typed, and cache values can be anything, type
-    // assertion is needed when values are being passed to functions that don't
-    // take arbitrary types, (i.e. interface{}). The simplest way to do this for
-    // values which will only be used once--e.g. for passing to another
-    // function--is:
-    foo, found := c.Get("foo")
-    if found {
-            MyFunction(foo.(string))
-    }
+// Get the string associated with the key "foo" from the cache
+foo, found := c.Get("foo")
+if found {
+        fmt.Println(foo)
+}
 
-    // This gets tedious if the value is used several times in the same function.
-    // You might do either of the following instead:
-    if x, found := c.Get("foo"); found {
-            foo := x.(string)
-            ...
-    }
-    // or
-    var foo string
-    if x, found := c.Get("foo"); found {
-            foo = x.(string)
-    }
-    ...
-    // foo can then be passed around freely as a string
+// Since Go is statically typed, and cache values can be anything, type
+// assertion is needed when values are being passed to functions that don't
+// take arbitrary types, (i.e. interface{}). The simplest way to do this for
+// values which will only be used once--e.g. for passing to another
+// function--is:
+foo, found := c.Get("foo")
+if found {
+        MyFunction(foo.(string))
+}
 
-    // Want performance? Store pointers!
-    c.Set("foo", &MyStruct, 0)
-    if x, found := c.Get("foo"); found {
-            foo := x.(*MyStruct)
-            ...
-    }
+// This gets tedious if the value is used several times in the same function.
+// You might do either of the following instead:
+if x, found := c.Get("foo"); found {
+        foo := x.(string)
+        ...
+}
+// or
+var foo string
+if x, found := c.Get("foo"); found {
+        foo = x.(string)
+}
+...
+// foo can then be passed around freely as a string
 
-    // If you store a reference type like a pointer, slice, map or channel, you
-    // do not need to run Set if you modify the underlying data. The cached
-    // reference points to the same memory, so if you modify a struct whose
-    // pointer you've stored in the cache, retrieving that pointer with Get will
-    // point you to the same data:
-    foo := &MyStruct{Num: 1}
-    c.Set("foo", foo, 0)
-    ...
-    x, _ := c.Get("foo")
-    foo := x.(*MyStruct)
-    fmt.Println(foo.Num)
-    ...
-    foo.Num++
-    ...
-    x, _ := c.Get("foo")
-    foo := x.(*MyStruct)
-    foo.Println(foo.Num)
+// Want performance? Store pointers!
+c.Set("foo", &MyStruct, 0)
+if x, found := c.Get("foo"); found {
+        foo := x.(*MyStruct)
+        ...
+}
 
-    // will print:
-    1
-    2
+// If you store a reference type like a pointer, slice, map or channel, you
+// do not need to run Set if you modify the underlying data. The cached
+// reference points to the same memory, so if you modify a struct whose
+// pointer you've stored in the cache, retrieving that pointer with Get will
+// point you to the same data:
+foo := &MyStruct{Num: 1}
+c.Set("foo", foo, 0)
+...
+x, _ := c.Get("foo")
+foo := x.(*MyStruct)
+fmt.Println(foo.Num)
+...
+foo.Num++
+...
+x, _ := c.Get("foo")
+foo := x.(*MyStruct)
+foo.Println(foo.Num)
+
+// will print:
+1
+2
 
 == Reference