Trait r2d2_redis_cluster::Commands

pub trait Commands: ConnectionLike {
    fn get<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn set_ex<K, V, RV>(
        &self, 
        key: K, 
        value: V, 
        seconds: usize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn del<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn setbit<K, RV>(
        &self, 
        key: K, 
        offset: usize, 
        value: bool
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn bitcount_range<K, RV>(
        &self, 
        key: K, 
        start: usize, 
        end: usize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError>
    where
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError>
    where
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hset<K, F, V, RV>(
        &self, 
        key: K, 
        field: F, 
        value: V
    ) -> Result<RV, RedisError>
    where
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn hset_nx<K, F, V, RV>(
        &self, 
        key: K, 
        field: F, 
        value: V
    ) -> Result<RV, RedisError>
    where
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn hset_multiple<K, F, V, RV>(
        &self, 
        key: K, 
        items: &[(F, V)]
    ) -> Result<RV, RedisError>
    where
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn hincr<K, F, D, RV>(
        &self, 
        key: K, 
        field: F, 
        delta: D
    ) -> Result<RV, RedisError>
    where
        D: ToRedisArgs,
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError>
    where
        F: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn brpoplpush<K, RV>(
        &self, 
        srckey: K, 
        dstkey: K, 
        timeout: usize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn linsert_before<K, P, V, RV>(
        &self, 
        key: K, 
        pivot: P, 
        value: V
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        P: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn linsert_after<K, P, V, RV>(
        &self, 
        key: K, 
        pivot: P, 
        value: V
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        P: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn lrange<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn lrem<K, V, RV>(
        &self, 
        key: K, 
        count: isize, 
        value: V
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn ltrim<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn lset<K, V, RV>(
        &self, 
        key: K, 
        index: isize, 
        value: V
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
        V: ToRedisArgs,
    { ... }
    fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn smove<K, M, RV>(
        &self, 
        srckey: K, 
        dstkey: K, 
        member: M
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn srandmember_multiple<K, RV>(
        &self, 
        key: K, 
        count: usize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zadd<K, S, M, RV>(
        &self, 
        key: K, 
        member: M, 
        score: S
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
        S: ToRedisArgs,
    { ... }
    fn zadd_multiple<K, S, M, RV>(
        &self, 
        key: K, 
        items: &[(S, M)]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
        S: ToRedisArgs,
    { ... }
    fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zcount<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zincr<K, M, D, RV>(
        &self, 
        key: K, 
        member: M, 
        delta: D
    ) -> Result<RV, RedisError>
    where
        D: ToRedisArgs,
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zinterstore<K, RV>(
        &self, 
        dstkey: K, 
        keys: &[K]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zinterstore_min<K, RV>(
        &self, 
        dstkey: K, 
        keys: &[K]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zinterstore_max<K, RV>(
        &self, 
        dstkey: K, 
        keys: &[K]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zlexcount<K, L, RV>(
        &self, 
        key: K, 
        min: L, 
        max: L
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        L: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrange<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrange_withscores<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrangebylex<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrangebylex_limit<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM, 
        offset: isize, 
        count: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrangebylex<K, MM, M, RV>(
        &self, 
        key: K, 
        max: MM, 
        min: M
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrangebylex_limit<K, MM, M, RV>(
        &self, 
        key: K, 
        max: MM, 
        min: M, 
        offset: isize, 
        count: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrangebyscore<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrangebyscore_withscores<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrangebyscore_limit<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM, 
        offset: isize, 
        count: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrangebyscore_limit_withscores<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM, 
        offset: isize, 
        count: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrembylex<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrembyrank<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrembyscore<K, M, MM, RV>(
        &self, 
        key: K, 
        min: M, 
        max: MM
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrange<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrange_withscores<K, RV>(
        &self, 
        key: K, 
        start: isize, 
        stop: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrangebyscore<K, MM, M, RV>(
        &self, 
        key: K, 
        max: MM, 
        min: M
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrangebyscore_withscores<K, MM, M, RV>(
        &self, 
        key: K, 
        max: MM, 
        min: M
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrangebyscore_limit<K, MM, M, RV>(
        &self, 
        key: K, 
        max: MM, 
        min: M, 
        offset: isize, 
        count: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
        &self, 
        key: K, 
        max: MM, 
        min: M, 
        offset: isize, 
        count: isize
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        MM: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        M: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zunionstore<K, RV>(
        &self, 
        dstkey: K, 
        keys: &[K]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zunionstore_min<K, RV>(
        &self, 
        dstkey: K, 
        keys: &[K]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zunionstore_max<K, RV>(
        &self, 
        dstkey: K, 
        keys: &[K]
    ) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError>
    where
        E: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn publish<K, E, RV>(
        &self, 
        channel: K, 
        message: E
    ) -> Result<RV, RedisError>
    where
        E: ToRedisArgs,
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn scan<RV>(&self) -> Result<Iter<RV>, RedisError>
    where
        RV: FromRedisValue,
    { ... }
    fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError>
    where
        P: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn hscan_match<K, P, RV>(
        &self, 
        key: K, 
        pattern: P
    ) -> Result<Iter<RV>, RedisError>
    where
        K: ToRedisArgs,
        P: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn sscan_match<K, P, RV>(
        &self, 
        key: K, 
        pattern: P
    ) -> Result<Iter<RV>, RedisError>
    where
        K: ToRedisArgs,
        P: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError>
    where
        K: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
    fn zscan_match<K, P, RV>(
        &self, 
        key: K, 
        pattern: P
    ) -> Result<Iter<RV>, RedisError>
    where
        K: ToRedisArgs,
        P: ToRedisArgs,
        RV: FromRedisValue,
    { ... }
}

Implements common redis commands for connection like objects. This allows you to send commands straight to a connection or client. It is also implemented for redis results of clients which makes for very convenient access in some basic cases.

This allows you to use nicer syntax for some common operations. For instance this code:

let client = redis::Client::open("redis://127.0.0.1/")?;
let con = client.get_connection()?;
redis::cmd("SET").arg("my_key").arg(42).execute(&con);
assert_eq!(redis::cmd("GET").arg("my_key").query(&con), Ok(42));

Will become this:

use redis::Commands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let con = client.get_connection()?;
assert_eq!(con.get("my_key"), Ok(42));

Provided methods

fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get the value of a key. If key is a vec this becomes an MGET.

fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Gets all keys matching pattern

fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Set the string value of a key.

fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Sets multiple keys to their values.

fn set_ex<K, V, RV>(
    &self,
    key: K,
    value: V,
    seconds: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Set the value and expiration of a key.

fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Set the value of a key, only if the key does not exist

fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Sets multiple keys to their values failing if at least one already exists.

fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Set the string value of a key and return its old value.

fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Delete one or more keys.

fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Determine if a key exists.

fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Set a key's time to live in seconds.

fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Set the expiration for a key as a UNIX timestamp.

fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Set a key's time to live in milliseconds.

fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Set the expiration for a key as a UNIX timestamp in milliseconds.

fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Remove the expiration from a key.

fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Check the expiration time of a key.

fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Rename a key.

fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Rename a key, only if the new key does not exist.

fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Append a value to a key.

fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Increment the numeric value of a key by the given amount. This issues a INCRBY or INCRBYFLOAT depending on the type.

fn setbit<K, RV>(
    &self,
    key: K,
    offset: usize,
    value: bool
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Sets or clears the bit at offset in the string value stored at key.

fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Returns the bit value at offset in the string value stored at key.

fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Count set bits in a string.

fn bitcount_range<K, RV>(
    &self,
    key: K,
    start: usize,
    end: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Count set bits in a string in a range.

fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Perform a bitwise AND between multiple keys (containing string values) and store the result in the destination key.

fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Perform a bitwise OR between multiple keys (containing string values) and store the result in the destination key.

fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Perform a bitwise XOR between multiple keys (containing string values) and store the result in the destination key.

fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Perform a bitwise NOT of the key (containing string values) and store the result in the destination key.

fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get the length of the value stored in a key.

fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

Gets a single (or multiple) fields from a hash.

fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

Deletes a single (or multiple) fields from a hash.

fn hset<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Sets a single field in a hash.

fn hset_nx<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Sets a single field in a hash if it does not exist.

fn hset_multiple<K, F, V, RV>(
    &self,
    key: K,
    items: &[(F, V)]
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Sets a multiple fields in a hash.

fn hincr<K, F, D, RV>(
    &self,
    key: K,
    field: F,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

Increments a value.

fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

Checks if a field in a hash exists.

fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Gets all the keys in a hash.

fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Gets all the values in a hash.

fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Gets all the fields and values in a hash.

fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Gets the length of a hash.

fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Remove and get the first element in a list, or block until one is available.

fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Remove and get the last element in a list, or block until one is available.

fn brpoplpush<K, RV>(
    &self,
    srckey: K,
    dstkey: K,
    timeout: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Pop a value from a list, push it to another list and return it; or block until one is available.

fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get an element from a list by its index.

fn linsert_before<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Insert an element before another element in a list.

fn linsert_after<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Insert an element after another element in a list.

fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Returns the length of the list stored at key.

fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Removes and returns the first element of the list stored at key.

fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Insert all the specified values at the head of the list stored at key.

fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Inserts a value at the head of the list stored at key, only if key already exists and holds a list.

fn lrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Returns the specified elements of the list stored at key.

fn lrem<K, V, RV>(
    &self,
    key: K,
    count: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Removes the first count occurrences of elements equal to value from the list stored at key.

fn ltrim<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Trim an existing list so that it will contain only the specified range of elements specified.

fn lset<K, V, RV>(
    &self,
    key: K,
    index: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Sets the list element at index to value

fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Removes and returns the last element of the list stored at key.

fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Pop a value from a list, push it to another list and return it.

fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Insert all the specified values at the tail of the list stored at key.

fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

Inserts value at the tail of the list stored at key, only if key already exists and holds a list.

fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Add one or more members to a set.

fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get the number of members in a set.

fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Subtract multiple sets.

fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Subtract multiple sets and store the resulting set in a key.

fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Intersect multiple sets.

fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Intersect multiple sets and store the resulting set in a key.

fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Determine if a given value is a member of a set.

fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get all the members in a set.

fn smove<K, M, RV>(
    &self,
    srckey: K,
    dstkey: K,
    member: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Move a member from one set to another.

fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Remove and return a random member from a set.

fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get one random member from a set.

fn srandmember_multiple<K, RV>(
    &self,
    key: K,
    count: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get multiple random members from a set.

fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Remove one or more members from a set.

fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Add multiple sets.

fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Add multiple sets and store the resulting set in a key.

fn zadd<K, S, M, RV>(
    &self,
    key: K,
    member: M,
    score: S
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

Add one member to a sorted set, or update its score if it already exists.

fn zadd_multiple<K, S, M, RV>(
    &self,
    key: K,
    items: &[(S, M)]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

Add multiple members to a sorted set, or update its score if it already exists.

fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Get the number of members in a sorted set.

fn zcount<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Count the members in a sorted set with scores within the given values.

fn zincr<K, M, D, RV>(
    &self,
    key: K,
    member: M,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Increments the member in a sorted set at key by delta. If the member does not exist, it is added with delta as its score.

fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Intersect multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.

fn zinterstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Intersect multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.

fn zinterstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Intersect multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.

fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    L: ToRedisArgs,
    RV: FromRedisValue, 

Count the number of members in a sorted set between a given lexicographical range.

fn zrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by index

fn zrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by index with scores.

fn zrangebylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by lexicographical range.

fn zrangebylex_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by lexicographical range with offset and limit.

fn zrevrangebylex<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by lexicographical range.

fn zrevrangebylex_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by lexicographical range with offset and limit.

fn zrangebyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score.

fn zrangebyscore_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score with scores.

fn zrangebyscore_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score with limit.

fn zrangebyscore_limit_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score with limit with scores.

fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Determine the index of a member in a sorted set.

fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Remove one or more members from a sorted set.

fn zrembylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Remove all members in a sorted set between the given lexicographical range.

fn zrembyrank<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Remove all members in a sorted set within the given indexes.

fn zrembyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Remove all members in a sorted set within the given scores.

fn zrevrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by index, with scores ordered from high to low.

fn zrevrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by index, with scores ordered from high to low.

fn zrevrangebyscore<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score.

fn zrevrangebyscore_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score with scores.

fn zrevrangebyscore_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score with limit.

fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

Return a range of members in a sorted set, by score with limit with scores.

fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Determine the index of a member in a sorted set, with scores ordered from high to low.

fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

Get the score associated with the given member in a sorted set.

fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Unions multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.

fn zunionstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Unions multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.

fn zunionstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Unions multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.

fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

Adds the specified elements to the specified HyperLogLog.

fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Merge N different HyperLogLogs into a single one.

fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

Posts a message to the given channel.

fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
    RV: FromRedisValue, 

Incrementally iterate the keys space.

fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
    P: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate the keys space for keys matching a pattern.

fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate hash fields and associated values.

fn hscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate hash fields and associated values for field names matching a pattern.

fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate set elements.

fn sscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate set elements for elements matching a pattern.

fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate sorted set elements.

fn zscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

Incrementally iterate sorted set elements for elements matching a pattern.

Loading content...

Implementations on Foreign Types

impl Commands for Connection

fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_ex<K, V, RV>(
    &self,
    key: K,
    value: V,
    seconds: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn setbit<K, RV>(
    &self,
    key: K,
    offset: usize,
    value: bool
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bitcount_range<K, RV>(
    &self,
    key: K,
    start: usize,
    end: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hset<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hset_nx<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hset_multiple<K, F, V, RV>(
    &self,
    key: K,
    items: &[(F, V)]
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hincr<K, F, D, RV>(
    &self,
    key: K,
    field: F,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn brpoplpush<K, RV>(
    &self,
    srckey: K,
    dstkey: K,
    timeout: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn linsert_before<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn linsert_after<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn lrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lrem<K, V, RV>(
    &self,
    key: K,
    count: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn ltrim<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lset<K, V, RV>(
    &self,
    key: K,
    index: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn smove<K, M, RV>(
    &self,
    srckey: K,
    dstkey: K,
    member: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srandmember_multiple<K, RV>(
    &self,
    key: K,
    count: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zadd<K, S, M, RV>(
    &self,
    key: K,
    member: M,
    score: S
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

fn zadd_multiple<K, S, M, RV>(
    &self,
    key: K,
    items: &[(S, M)]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zcount<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zincr<K, M, D, RV>(
    &self,
    key: K,
    member: M,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    L: ToRedisArgs,
    RV: FromRedisValue, 

fn zrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebylex_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebylex<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebylex_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_limit_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembyrank<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
    RV: FromRedisValue, 

fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

impl Commands for Client

fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_ex<K, V, RV>(
    &self,
    key: K,
    value: V,
    seconds: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn setbit<K, RV>(
    &self,
    key: K,
    offset: usize,
    value: bool
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bitcount_range<K, RV>(
    &self,
    key: K,
    start: usize,
    end: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hset<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hset_nx<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hset_multiple<K, F, V, RV>(
    &self,
    key: K,
    items: &[(F, V)]
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hincr<K, F, D, RV>(
    &self,
    key: K,
    field: F,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn brpoplpush<K, RV>(
    &self,
    srckey: K,
    dstkey: K,
    timeout: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn linsert_before<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn linsert_after<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn lrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lrem<K, V, RV>(
    &self,
    key: K,
    count: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn ltrim<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lset<K, V, RV>(
    &self,
    key: K,
    index: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn smove<K, M, RV>(
    &self,
    srckey: K,
    dstkey: K,
    member: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srandmember_multiple<K, RV>(
    &self,
    key: K,
    count: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zadd<K, S, M, RV>(
    &self,
    key: K,
    member: M,
    score: S
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

fn zadd_multiple<K, S, M, RV>(
    &self,
    key: K,
    items: &[(S, M)]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zcount<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zincr<K, M, D, RV>(
    &self,
    key: K,
    member: M,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    L: ToRedisArgs,
    RV: FromRedisValue, 

fn zrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebylex_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebylex<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebylex_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_limit_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembyrank<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
    RV: FromRedisValue, 

fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

impl Commands for Connection

fn get<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn keys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn set<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_multiple<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_ex<K, V, RV>(
    &self,
    key: K,
    value: V,
    seconds: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn set_nx<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn mset_nx<K, V, RV>(&self, items: &[(K, V)]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn getset<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn del<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn exists<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn expire<K, RV>(&self, key: K, seconds: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn expire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pexpire<K, RV>(&self, key: K, ms: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pexpire_at<K, RV>(&self, key: K, ts: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn persist<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn ttl<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rename<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rename_nx<K, RV>(&self, key: K, new_key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn append<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn incr<K, V, RV>(&self, key: K, delta: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn setbit<K, RV>(
    &self,
    key: K,
    offset: usize,
    value: bool
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn getbit<K, RV>(&self, key: K, offset: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bitcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bitcount_range<K, RV>(
    &self,
    key: K,
    start: usize,
    end: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_and<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_or<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_xor<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn bit_not<K, RV>(&self, dstkey: K, srckey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn strlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hget<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hdel<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hset<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hset_nx<K, F, V, RV>(
    &self,
    key: K,
    field: F,
    value: V
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hset_multiple<K, F, V, RV>(
    &self,
    key: K,
    items: &[(F, V)]
) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn hincr<K, F, D, RV>(
    &self,
    key: K,
    field: F,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hexists<K, F, RV>(&self, key: K, field: F) -> Result<RV, RedisError> where
    F: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hkeys<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hvals<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hgetall<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hlen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn blpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn brpop<K, RV>(&self, key: K, timeout: usize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn brpoplpush<K, RV>(
    &self,
    srckey: K,
    dstkey: K,
    timeout: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lindex<K, RV>(&self, key: K, index: isize) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn linsert_before<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn linsert_after<K, P, V, RV>(
    &self,
    key: K,
    pivot: P,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn llen<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn lpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn lrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lrem<K, V, RV>(
    &self,
    key: K,
    count: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn ltrim<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn lset<K, V, RV>(
    &self,
    key: K,
    index: isize,
    value: V
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn rpop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rpoplpush<K, RV>(&self, key: K, dstkey: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn rpush<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn rpush_exists<K, V, RV>(&self, key: K, value: V) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue,
    V: ToRedisArgs, 

fn sadd<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn scard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdiff<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdiffstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sinter<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sdinterstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sismember<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn smembers<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn smove<K, M, RV>(
    &self,
    srckey: K,
    dstkey: K,
    member: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn spop<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srandmember<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srandmember_multiple<K, RV>(
    &self,
    key: K,
    count: usize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn srem<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn sunion<K, RV>(&self, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sunionstore<K, RV>(&self, dstkey: K, keys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zadd<K, S, M, RV>(
    &self,
    key: K,
    member: M,
    score: S
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

fn zadd_multiple<K, S, M, RV>(
    &self,
    key: K,
    items: &[(S, M)]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue,
    S: ToRedisArgs, 

fn zcard<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zcount<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zincr<K, M, D, RV>(
    &self,
    key: K,
    member: M,
    delta: D
) -> Result<RV, RedisError> where
    D: ToRedisArgs,
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zinterstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zlexcount<K, L, RV>(&self, key: K, min: L, max: L) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    L: ToRedisArgs,
    RV: FromRedisValue, 

fn zrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebylex_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebylex<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebylex_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_limit<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrangebyscore_limit_withscores<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zrem<K, M, RV>(&self, key: K, members: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembylex<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembyrank<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrembyscore<K, M, MM, RV>(
    &self,
    key: K,
    min: M,
    max: MM
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrange<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrange_withscores<K, RV>(
    &self,
    key: K,
    start: isize,
    stop: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_limit<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrangebyscore_limit_withscores<K, MM, M, RV>(
    &self,
    key: K,
    max: MM,
    min: M,
    offset: isize,
    count: isize
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    MM: ToRedisArgs,
    RV: FromRedisValue, 

fn zrevrank<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zscore<K, M, RV>(&self, key: K, member: M) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    M: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore<K, RV>(&self, dstkey: K, keys: &[K]) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore_min<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zunionstore_max<K, RV>(
    &self,
    dstkey: K,
    keys: &[K]
) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfadd<K, E, RV>(&self, key: K, element: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfcount<K, RV>(&self, key: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn pfmerge<K, RV>(&self, dstkey: K, srckeys: K) -> Result<RV, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn publish<K, E, RV>(&self, channel: K, message: E) -> Result<RV, RedisError> where
    E: ToRedisArgs,
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn scan<RV>(&self) -> Result<Iter<RV>, RedisError> where
    RV: FromRedisValue, 

fn scan_match<P, RV>(&self, pattern: P) -> Result<Iter<RV>, RedisError> where
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn hscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn hscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn sscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn sscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

fn zscan<K, RV>(&self, key: K) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    RV: FromRedisValue, 

fn zscan_match<K, P, RV>(
    &self,
    key: K,
    pattern: P
) -> Result<Iter<RV>, RedisError> where
    K: ToRedisArgs,
    P: ToRedisArgs,
    RV: FromRedisValue, 

Loading content...

Implementors

Loading content...