Optimize simple strings for +OK\r\n responses

Previously, `redis.set "foo", "bar"` allocated 16 bytes of heap memory
for the "OK" response from the server. With this commit, it doesn't
allocate any heap memory at all.

spec/parser_spec.cr

@@ -12,8 +12,13 @@ module Redis
     end
 
     it "reads simple strings" do
-      io = IO::Memory.new("+OK\r\n")
-      Parser.new(io).read.should eq "OK"
+      io = IO::Memory.new("+OK\r\n+QUEUED\r\n+OK\r\n+QUEUED\r\n")
+      parser = Parser.new(io)
+
+      2.times do
+        parser.read.should eq "OK"
+        parser.read.should eq "QUEUED"
+      end
     end
 
     it "reads bulk strings" do

spec/redis_spec.cr

@@ -27,7 +27,7 @@ end
 describe Redis::Client do
   test "can set, get, and delete keys" do
     redis.get(random_key).should eq nil
-    redis.set(key, "hello")
+    redis.set(key, "hello").should eq "OK"
     redis.get(key).should eq "hello"
     redis.del(key).should eq 1
     redis.del(key).should eq 0

src/parser.cr

@@ -48,7 +48,22 @@ module Redis
           value
         end
       when '+'
-        @io.read_line
+        # Most of the time, RESP simple strings are just "OK", so we can
+        # optimize for that case to avoid heap allocations. If it is *not* the
+        # "OK" string, this does an extra heap allocation, but that seems like
+        # a decent tradeoff considering the vast majority of times a simple
+        # string will be returned from the server is from a SET call.
+        buffer = uninitialized UInt8[4] # "OK\r\n"
+        slice = buffer.to_slice
+        read = @io.read slice
+        result = if read == 4 && slice == "OK\r\n".to_slice
+          "OK"
+        else
+          String.build do |str|
+            str.write slice[0...read]
+            str << @io.read_line
+          end
+        end
       when '-'
         type, message = @io.read_line.split(' ', 2)
         ERROR_MAP[type].new("#{type} #{message}")