Get rid of dummy selfs.

Author: mitsuhiko

src/redis/commands.rs

@@ -17,7 +17,7 @@ macro_rules! implement_commands {
         $(
             $(#[$attr:meta])+
             fn $name:ident<$($tyargs:ident : $ty:ident),*>(
-                $self_:ident$(, $argname:ident: $argty:ty)*) $body:block
+                $($argname:ident: $argty:ty),*) $body:block
         )*
     ) =>
     (
@@ -50,8 +50,8 @@ macro_rules! implement_commands {
             $(
                 $(#[$attr])*
                 fn $name<$($tyargs: $ty,)* RV: FromRedisValue>(
-                    &$self_ $(, $argname: $argty)*) -> RedisResult<RV>
-                    { $self_.perform($body) }
+                    &self $(, $argname: $argty)*) -> RedisResult<RV>
+                    { self.perform($body) }
             )*
         }
 
@@ -65,8 +65,8 @@ macro_rules! implement_commands {
             $(
                 $(#[$attr])*
                 fn $name<'a $(, $tyargs: $ty)*>(
-                    &'a mut $self_ $(, $argname: $argty)*) -> &'a mut Self
-                    { $self_.perform($body) }
+                    &'a mut self $(, $argname: $argty)*) -> &'a mut Self
+                    { self.perform($body) }
             )*
         }
     )
@@ -76,85 +76,85 @@ implement_commands!(
     // most common operations
 
     #[doc="Get the value of a key.  If key is a vec this becomes an `MGET`."]
-    fn get<K: ToRedisArgs>(self, key: K) {
+    fn get<K: ToRedisArgs>(key: K) {
         cmd(if key.is_single_arg() { "GET" } else { "MGET" }).arg(key)
     }
 
     #[doc="Set the string value of a key."]
-    fn set<K: ToRedisArgs, V: ToRedisArgs>(self, key: K, value: V) {
+    fn set<K: ToRedisArgs, V: ToRedisArgs>(key: K, value: V) {
         cmd("SET").arg(key).arg(value)
     }
 
     #[doc="Set the value and expiration of a key."]
-    fn set_ex<K: ToRedisArgs, V: ToRedisArgs>(self, key: K, value: V, seconds: uint) {
+    fn set_ex<K: ToRedisArgs, V: ToRedisArgs>(key: K, value: V, seconds: uint) {
         cmd("SETEX").arg(key).arg(value).arg(seconds)
     }
 
     #[doc="Set the value of a key, only if the key does not exist"]
-    fn set_nx<K: ToRedisArgs, V: ToRedisArgs>(self, key: K, value: V) {
+    fn set_nx<K: ToRedisArgs, V: ToRedisArgs>(key: K, value: V) {
         cmd("SETNX").arg(key).arg(value)
     }
 
     #[doc="Set the string value of a key and return its old value."]
-    fn getset<K: ToRedisArgs, V: ToRedisArgs>(self, key: K, value: V) {
+    fn getset<K: ToRedisArgs, V: ToRedisArgs>(key: K, value: V) {
         cmd("GETSET").arg(key).arg(value)
     }
 
     #[doc="Delete one or more keys."]
-    fn del<K: ToRedisArgs>(self, key: K) {
+    fn del<K: ToRedisArgs>(key: K) {
         cmd("DEL").arg(key)
     }
 
     #[doc="Determine if a key exists."]
-    fn exists<K: ToRedisArgs>(self, key: K) {
+    fn exists<K: ToRedisArgs>(key: K) {
         cmd("EXISTS").arg(key)
     }
 
     #[doc="Set a key's time to live in seconds."]
-    fn expire<K: ToRedisArgs>(self, key: K, seconds: uint) {
+    fn expire<K: ToRedisArgs>(key: K, seconds: uint) {
         cmd("EXPIRE").arg(key).arg(seconds)
     }
 
     #[doc="Set the expiration for a key as a UNIX timestamp."]
-    fn expire_at<K: ToRedisArgs>(self, key: K, ts: uint) {
+    fn expire_at<K: ToRedisArgs>(key: K, ts: uint) {
         cmd("EXPIREAT").arg(key).arg(ts)
     }
 
     #[doc="Set a key's time to live in milliseconds."]
-    fn pexpire<K: ToRedisArgs>(self, key: K, ms: uint) {
+    fn pexpire<K: ToRedisArgs>(key: K, ms: uint) {
         cmd("PEXPIRE").arg(key).arg(ms)
     }
 
     #[doc="Set the expiration for a key as a UNIX timestamp in milliseconds."]
-    fn pexpire_at<K: ToRedisArgs>(self, key: K, ts: uint) {
+    fn pexpire_at<K: ToRedisArgs>(key: K, ts: uint) {
         cmd("PEXPIREAT").arg(key).arg(ts)
     }
 
     #[doc="Remove the expiration from a key."]
-    fn persist<K: ToRedisArgs>(self, key: K) {
+    fn persist<K: ToRedisArgs>(key: K) {
         cmd("PERSIST").arg(key)
     }
 
     #[doc="Rename a key."]
-    fn rename<K: ToRedisArgs>(self, key: K, new_key: K) {
+    fn rename<K: ToRedisArgs>(key: K, new_key: K) {
         cmd("RENAME").arg(key).arg(new_key)
     }
 
     #[doc="Rename a key, only if the new key does not exist."]
-    fn rename_nx<K: ToRedisArgs>(self, key: K, new_key: K) {
+    fn rename_nx<K: ToRedisArgs>(key: K, new_key: K) {
         cmd("RENAMENX").arg(key).arg(new_key)
     }
 
     // common string operations
 
     #[doc="Append a value to a key."]
-    fn append<K: ToRedisArgs, V: ToRedisArgs>(self, key: K, value: V) {
+    fn append<K: ToRedisArgs, V: ToRedisArgs>(key: K, value: V) {
         cmd("APPEND").arg(key).arg(value)
     }
 
     #[doc="Increment the numeric value of a key by the given amount.  This 
           issues a `INCR` or `INCRBYFLOAT` depending on the type."]
-    fn incr<K: ToRedisArgs, V: ToRedisArgs>(self, key: K, delta: V) {
+    fn incr<K: ToRedisArgs, V: ToRedisArgs>(key: K, delta: V) {
         cmd(if delta.describe_numeric_behavior() == NumberIsFloat {
             "INCRBYFLOAT"
         } else {
@@ -163,28 +163,28 @@ implement_commands!(
     }
 
     #[doc="Sets or clears the bit at offset in the string value stored at key."]
-    fn setbit<K: ToRedisArgs>(self, key: K, offset: uint, value: bool) {
+    fn setbit<K: ToRedisArgs>(key: K, offset: uint, value: bool) {
         cmd("SETBIT").arg(key).arg(offset).arg(value)
     }
 
     #[doc="Returns the bit value at offset in the string value stored at key."]
-    fn getbit<K: ToRedisArgs>(self, key: K, offset: uint) {
+    fn getbit<K: ToRedisArgs>(key: K, offset: uint) {
         cmd("GETBIT").arg(key).arg(offset)
     }
 
     #[doc="Count set bits in a string."]
-    fn bitcount<K: ToRedisArgs>(self, key: K) {
+    fn bitcount<K: ToRedisArgs>(key: K) {
         cmd("BITCOUNT").arg(key)
     }
 
     #[doc="Count set bits in a string in a range."]
-    fn bitcount_range<K: ToRedisArgs>(self, key: K, start: uint, end: uint) {
+    fn bitcount_range<K: ToRedisArgs>(key: K, start: uint, end: uint) {
         cmd("BITCOUNT").arg(key).arg(start).arg(end)
     }
 
     #[doc="Perform a bitwise operation between multiple keys (containing string values)
         and store the result in the destination key."]
-    fn bitop<K: ToRedisArgs>(self, op: BitOp, dstkey: K, srckeys: K) {
+    fn bitop<K: ToRedisArgs>(op: BitOp, dstkey: K, srckeys: K) {
         cmd("BITOP").arg(match op {
             BitAnd => "AND",
             BitOr => "OR",
@@ -194,7 +194,7 @@ implement_commands!(
     }
 
     #[doc="Get the length of the value stored in a key."]
-    fn strlen<K: ToRedisArgs>(self, key: K) {
+    fn strlen<K: ToRedisArgs>(key: K) {
         cmd("STRLEN").arg(key)
     }
 )