Remove leading spaces from README

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