Trait redis_cluster_rs::PipelineCommands[−][src]

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

Implements common redis commands for pipelines. Unlike the regular commands trait, this returns the pipeline rather than a result directly. Other than that it works the same however.

Provided Methods

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn get<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn keys<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Gets all keys matching pattern

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn set<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

Set the string value of a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn set_multiple<K, V>(&mut self, items: &[(K, V)]) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

Sets multiple keys to their values.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn set_ex<K, V>(&mut self, key: K, value: V, seconds: usize) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

Set the value and expiration of a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn set_nx<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn mset_nx<K, V>(&mut self, items: &[(K, V)]) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn getset<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn del<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Delete one or more keys.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn exists<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Determine if a key exists.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn expire<K>(&mut self, key: K, seconds: usize) -> &mut Self where K: ToRedisArgs,`

Set a key's time to live in seconds.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn expire_at<K>(&mut self, key: K, ts: usize) -> &mut Self where K: ToRedisArgs,`

Set the expiration for a key as a UNIX timestamp.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn pexpire<K>(&mut self, key: K, ms: usize) -> &mut Self where K: ToRedisArgs,`

Set a key's time to live in milliseconds.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn pexpire_at<K>(&mut self, key: K, ts: usize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn persist<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Remove the expiration from a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn ttl<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Check the expiration time of a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn rename<K>(&mut self, key: K, new_key: K) -> &mut Self where K: ToRedisArgs,`

Rename a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn rename_nx<K>(&mut self, key: K, new_key: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn append<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

Append a value to a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn incr<K, V>(&mut self, key: K, delta: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn setbit<K>(&mut self, key: K, offset: usize, value: bool) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn getbit<K>(&mut self, key: K, offset: usize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn bitcount<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Count set bits in a string.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn bitcount_range<K>(&mut self, key: K, start: usize, end: usize) -> &mut Self where K: ToRedisArgs,`

Count set bits in a string in a range.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn bit_and<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn bit_or<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn bit_xor<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn bit_not<K>(&mut self, dstkey: K, srckey: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn strlen<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Get the length of the value stored in a key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hget<K, F>(&mut self, key: K, field: F) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hdel<K, F>(&mut self, key: K, field: F) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hset<K, F, V>(&mut self, key: K, field: F, value: V) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs, V: ToRedisArgs,`

Sets a single field in a hash.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hset_nx<K, F, V>(&mut self, key: K, field: F, value: V) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hset_multiple<K, F, V>(&mut self, key: K, items: &[(F, V)]) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs, V: ToRedisArgs,`

Sets a multiple fields in a hash.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hincr<K, F, D>(&mut self, key: K, field: F, delta: D) -> &mut Self where D: ToRedisArgs, F: ToRedisArgs, K: ToRedisArgs,`

Increments a value.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hexists<K, F>(&mut self, key: K, field: F) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs,`

Checks if a field in a hash exists.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hkeys<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Gets all the keys in a hash.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hvals<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Gets all the values in a hash.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hgetall<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Gets all the fields and values in a hash.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn hlen<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Gets the length of a hash.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn blpop<K>(&mut self, key: K, timeout: usize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn brpop<K>(&mut self, key: K, timeout: usize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn brpoplpush<K>(&mut self, srckey: K, dstkey: K, timeout: usize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lindex<K>(&mut self, key: K, index: isize) -> &mut Self where K: ToRedisArgs,`

Get an element from a list by its index.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn linsert_before<K, P, V>(&mut self, key: K, pivot: P, value: V) -> &mut Self where K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs,`

Insert an element before another element in a list.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn linsert_after<K, P, V>(&mut self, key: K, pivot: P, value: V) -> &mut Self where K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs,`

Insert an element after another element in a list.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn llen<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Returns the length of the list stored at key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lpop<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lpush<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lpush_exists<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lrange<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`

Returns the specified elements of the list stored at key.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lrem<K, V>(&mut self, key: K, count: isize, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn ltrim<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn lset<K, V>(&mut self, key: K, index: isize, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

Sets the list element at index to value

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn rpop<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn rpoplpush<K>(&mut self, key: K, dstkey: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn rpush<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn rpush_exists<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sadd<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

Add one or more members to a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn scard<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Get the number of members in a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sdiff<K>(&mut self, keys: K) -> &mut Self where K: ToRedisArgs,`

Subtract multiple sets.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sdiffstore<K>(&mut self, dstkey: K, keys: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sinter<K>(&mut self, keys: K) -> &mut Self where K: ToRedisArgs,`

Intersect multiple sets.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sdinterstore<K>(&mut self, dstkey: K, keys: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sismember<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn smembers<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Get all the members in a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn smove<K, M>(&mut self, srckey: K, dstkey: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

Move a member from one set to another.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn spop<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Remove and return a random member from a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn srandmember<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Get one random member from a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn srandmember_multiple<K>(&mut self, key: K, count: usize) -> &mut Self where K: ToRedisArgs,`

Get multiple random members from a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn srem<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

Remove one or more members from a set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sunion<K>(&mut self, keys: K) -> &mut Self where K: ToRedisArgs,`

Add multiple sets.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn sunionstore<K>(&mut self, dstkey: K, keys: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zadd<K, S, M>(&mut self, key: K, member: M, score: S) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, S: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zadd_multiple<K, S, M>(&mut self, key: K, items: &[(S, M)]) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, S: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zcard<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

Get the number of members in a sorted set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zcount<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zincr<K, M, D>(&mut self, key: K, member: M, delta: D) -> &mut Self where D: ToRedisArgs, K: ToRedisArgs, M: ToRedisArgs,`

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.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zinterstore<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zinterstore_min<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zinterstore_max<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zlexcount<K, L>(&mut self, key: K, min: L, max: L) -> &mut Self where K: ToRedisArgs, L: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrange<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrange_withscores<K>( &mut self, key: K, start: isize, stop: isize ) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrangebylex<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrangebylex_limit<K, M, MM>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrangebylex<K, MM, M>(&mut self, key: K, max: MM, min: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrangebylex_limit<K, MM, M>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrangebyscore<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrangebyscore_withscores<K, M, MM>( &mut self, key: K, min: M, max: MM ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrangebyscore_limit<K, M, MM>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrangebyscore_limit_withscores<K, M, MM>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrank<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

Determine the index of a member in a sorted set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrem<K, M>(&mut self, key: K, members: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

Remove one or more members from a sorted set.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrembylex<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrembyrank<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrembyscore<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrange<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrange_withscores<K>( &mut self, key: K, start: isize, stop: isize ) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrangebyscore<K, MM, M>(&mut self, key: K, max: MM, min: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrangebyscore_withscores<K, MM, M>( &mut self, key: K, max: MM, min: M ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrangebyscore_limit<K, MM, M>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrangebyscore_limit_withscores<K, MM, M>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zrevrank<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zscore<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zunionstore<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zunionstore_min<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn zunionstore_max<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn pfadd<K, E>(&mut self, key: K, element: E) -> &mut Self where E: ToRedisArgs, K: ToRedisArgs,`

Adds the specified elements to the specified HyperLogLog.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn pfcount<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`

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

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn pfmerge<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`

Merge N different HyperLogLogs into a single one.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,     type Item = <I as Iterator>::Item;

`fn publish<K, E>(&mut self, channel: K, message: E) -> &mut Self where E: ToRedisArgs, K: ToRedisArgs,`

Posts a message to the given channel.

Implementations on Foreign Types

`impl PipelineCommands for Pipeline`
[src]

`fn perform(&mut self, cmd: &Cmd) -> &mut Pipeline`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn get<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn keys<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn set<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn set_multiple<K, V>(&mut self, items: &[(K, V)]) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn set_ex<K, V>(&mut self, key: K, value: V, seconds: usize) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn set_nx<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn mset_nx<K, V>(&mut self, items: &[(K, V)]) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn getset<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn del<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn exists<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn expire<K>(&mut self, key: K, seconds: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn expire_at<K>(&mut self, key: K, ts: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn pexpire<K>(&mut self, key: K, ms: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn pexpire_at<K>(&mut self, key: K, ts: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn persist<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn ttl<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn rename<K>(&mut self, key: K, new_key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn rename_nx<K>(&mut self, key: K, new_key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn append<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn incr<K, V>(&mut self, key: K, delta: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn setbit<K>(&mut self, key: K, offset: usize, value: bool) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn getbit<K>(&mut self, key: K, offset: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn bitcount<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn bitcount_range<K>(&mut self, key: K, start: usize, end: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn bit_and<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn bit_or<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn bit_xor<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn bit_not<K>(&mut self, dstkey: K, srckey: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn strlen<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hget<K, F>(&mut self, key: K, field: F) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hdel<K, F>(&mut self, key: K, field: F) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hset<K, F, V>(&mut self, key: K, field: F, value: V) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hset_nx<K, F, V>(&mut self, key: K, field: F, value: V) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hset_multiple<K, F, V>(&mut self, key: K, items: &[(F, V)]) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hincr<K, F, D>(&mut self, key: K, field: F, delta: D) -> &mut Self where D: ToRedisArgs, F: ToRedisArgs, K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hexists<K, F>(&mut self, key: K, field: F) -> &mut Self where F: ToRedisArgs, K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hkeys<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hvals<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hgetall<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn hlen<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn blpop<K>(&mut self, key: K, timeout: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn brpop<K>(&mut self, key: K, timeout: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn brpoplpush<K>(&mut self, srckey: K, dstkey: K, timeout: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lindex<K>(&mut self, key: K, index: isize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn linsert_before<K, P, V>(&mut self, key: K, pivot: P, value: V) -> &mut Self where K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn linsert_after<K, P, V>(&mut self, key: K, pivot: P, value: V) -> &mut Self where K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn llen<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lpop<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lpush<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lpush_exists<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lrange<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lrem<K, V>(&mut self, key: K, count: isize, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn ltrim<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn lset<K, V>(&mut self, key: K, index: isize, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn rpop<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn rpoplpush<K>(&mut self, key: K, dstkey: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn rpush<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn rpush_exists<K, V>(&mut self, key: K, value: V) -> &mut Self where K: ToRedisArgs, V: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sadd<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn scard<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sdiff<K>(&mut self, keys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sdiffstore<K>(&mut self, dstkey: K, keys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sinter<K>(&mut self, keys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sdinterstore<K>(&mut self, dstkey: K, keys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sismember<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn smembers<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn smove<K, M>(&mut self, srckey: K, dstkey: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn spop<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn srandmember<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn srandmember_multiple<K>(&mut self, key: K, count: usize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn srem<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sunion<K>(&mut self, keys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn sunionstore<K>(&mut self, dstkey: K, keys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zadd<K, S, M>(&mut self, key: K, member: M, score: S) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, S: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zadd_multiple<K, S, M>(&mut self, key: K, items: &[(S, M)]) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, S: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zcard<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zcount<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zincr<K, M, D>(&mut self, key: K, member: M, delta: D) -> &mut Self where D: ToRedisArgs, K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zinterstore<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zinterstore_min<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zinterstore_max<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zlexcount<K, L>(&mut self, key: K, min: L, max: L) -> &mut Self where K: ToRedisArgs, L: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrange<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrange_withscores<K>( &mut self, key: K, start: isize, stop: isize ) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrangebylex<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrangebylex_limit<K, M, MM>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrangebylex<K, MM, M>(&mut self, key: K, max: MM, min: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrangebylex_limit<K, MM, M>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrangebyscore<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrangebyscore_withscores<K, M, MM>( &mut self, key: K, min: M, max: MM ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrangebyscore_limit<K, M, MM>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrangebyscore_limit_withscores<K, M, MM>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrank<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrem<K, M>(&mut self, key: K, members: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrembylex<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrembyrank<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrembyscore<K, M, MM>(&mut self, key: K, min: M, max: MM) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrange<K>(&mut self, key: K, start: isize, stop: isize) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrange_withscores<K>( &mut self, key: K, start: isize, stop: isize ) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrangebyscore<K, MM, M>(&mut self, key: K, max: MM, min: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrangebyscore_withscores<K, MM, M>( &mut self, key: K, max: MM, min: M ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrangebyscore_limit<K, MM, M>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrangebyscore_limit_withscores<K, MM, M>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zrevrank<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zscore<K, M>(&mut self, key: K, member: M) -> &mut Self where K: ToRedisArgs, M: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zunionstore<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zunionstore_min<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn zunionstore_max<K>(&mut self, dstkey: K, keys: &[K]) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn pfadd<K, E>(&mut self, key: K, element: E) -> &mut Self where E: ToRedisArgs, K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn pfcount<K>(&mut self, key: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn pfmerge<K>(&mut self, dstkey: K, srckeys: K) -> &mut Self where K: ToRedisArgs,`
[src]

ⓘImportant traits for &'a mut R
Important traits for &'a mut R
`impl<'a, R> Read for &'a mut R where R: Read + ?Sized, impl<'a, W> Write for &'a mut W where W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where I: Iterator + ?Sized, type Item = ::Item;`
`fn publish<K, E>(&mut self, channel: K, message: E) -> &mut Self where E: ToRedisArgs, K: ToRedisArgs,`
[src]