Update README to enable syntax highlighting

README.md

@@ -25,68 +25,76 @@ Getting started
 
 Let's start with connecting to Redis using TCP:
 
-    password := ""  // no password set
-    db := int64(-1) // use default DB
-    client := redis.NewTCPClient("localhost:6379", password, db)
-    defer client.Close()
-
-    ping := client.Ping()
-    fmt.Println(ping.Err(), ping.Val())
-    // Output: <nil> PONG
+```go
+password := ""  // no password set
+db := int64(-1) // use default DB
+client := redis.NewTCPClient("localhost:6379", password, db)
+defer client.Close()
 
+ping := client.Ping()
+fmt.Println(ping.Err(), ping.Val())
+// Output: <nil> PONG
+```
 or using Unix socket:
 
-    client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
-    defer client.Close()
-
-    ping := client.Ping()
-    fmt.Println(ping.Err(), ping.Val())
-    // Output: <nil> PONG
+```go
+client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
+defer client.Close()
 
+ping := client.Ping()
+fmt.Println(ping.Err(), ping.Val())
+// Output: <nil> PONG
+```
 Then we can start sending commands:
 
-    set := client.Set("foo", "bar")
-    fmt.Println(set.Err(), set.Val())
+```go
+set := client.Set("foo", "bar")
+fmt.Println(set.Err(), set.Val())
 
-    get := client.Get("foo")
-    fmt.Println(get.Err(), get.Val())
+get := client.Get("foo")
+fmt.Println(get.Err(), get.Val())
 
-    // Output: <nil> OK
-    // <nil> bar
+// Output: <nil> OK
+// <nil> bar
+```
 
 We can also pipeline two commands together:
 
-    var set *redis.StatusReq
-    var get *redis.StringReq
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
+```go
+var set *redis.StatusReq
+var get *redis.StringReq
+reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
     set = c.Set("key1", "hello1")
     get = c.Get("key2")
-    })
-    fmt.Println(err, reqs)
-    fmt.Println(set)
-    fmt.Println(get)
-    // Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
-    // SET key1 hello1: OK
-    // GET key2: (nil)
-
+})
+fmt.Println(err, reqs)
+fmt.Println(set)
+fmt.Println(get)
+// Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
+// SET key1 hello1: OK
+// GET key2: (nil)
+```
 or:
 
-    var set *redis.StatusReq
-    var get *redis.StringReq
-    reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
+```go
+var set *redis.StatusReq
+var get *redis.StringReq
+reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
     set = c.Set("key1", "hello1")
     get = c.Get("key2")
-    })
-    fmt.Println(err, reqs)
-    fmt.Println(set)
-    fmt.Println(get)
-    // Output: <nil> [SET key1 hello1 GET key2]
-    // SET key1 hello1
-    // GET key2
+})
+fmt.Println(err, reqs)
+fmt.Println(set)
+fmt.Println(get)
+// Output: <nil> [SET key1 hello1 GET key2]
+// SET key1 hello1
+// GET key2
+```
 
 We can also send several commands in transaction:
 
-    func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
+```go
+func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
     get := multi.Get("key")
     if err := get.Err(); err != nil && err != redis.Nil {
         return nil, err
@@ -102,55 +110,62 @@ We can also send several commands in transaction:
         return transaction(multi)
     }
     return reqs, err
-    }
+}
 
-    multi, err := client.MultiClient()
-    _ = err
-    defer multi.Close()
+multi, err := client.MultiClient()
+_ = err
+defer multi.Close()
 
-    watch := multi.Watch("key")
-    _ = watch.Err()
+watch := multi.Watch("key")
+_ = watch.Err()
 
-    reqs, err := transaction(multi)
-    fmt.Println(err, reqs)
+reqs, err := transaction(multi)
+fmt.Println(err, reqs)
 
-    // Output: <nil> [SET key 1: OK]
+// Output: <nil> [SET key 1: OK]
+```
 
 To subscribe to the channel:
 
-    pubsub, err := client.PubSubClient()
-    defer pubsub.Close()
+```go
+pubsub, err := client.PubSubClient()
+defer pubsub.Close()
 
-    ch, err := pubsub.Subscribe("mychannel")
-    _ = err
+ch, err := pubsub.Subscribe("mychannel")
+_ = err
 
-    subscribeMsg := <-ch
-    fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
+subscribeMsg := <-ch
+fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
 
-    pub := client.Publish("mychannel", "hello")
-    _ = pub.Err()
+pub := client.Publish("mychannel", "hello")
+_ = pub.Err()
 
-    msg := <-ch
-    fmt.Println(msg.Err, msg.Message)
+msg := <-ch
+fmt.Println(msg.Err, msg.Message)
 
-    // Output: <nil> subscribe
-    // <nil> hello
+// Output: <nil> subscribe
+// <nil> hello
+```
 
 You can also write custom commands:
 
-    func Get(client *redis.Client, key string) *redis.StringReq {
+```go
+func Get(client *redis.Client, key string) *redis.StringReq {
     req := redis.NewStringReq("GET", key)
     client.Process(req)
     return req
-    }
+}
 
-    get := Get(client, "key_does_not_exist")
-    fmt.Println(get.Err(), get.Val())
-    // Output: (nil)
+get := Get(client, "key_does_not_exist")
+fmt.Println(get.Err(), get.Val())
+// Output: (nil)
+```
 
 Client uses connection pool to send commands. You can change maximum number of connections with:
 
-    client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
+```go
+client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
+```
 
 Look and feel
 -------------