lettucef-core/dev.naoh.lettucef.core.async/SortedSetCommands

SortedSetCommands

trait SortedSetCommands[F[_], K, V] extends CommandsDeps[F, K, V] with SortedSetCommandsF[<none>, K, V]
trait SortedSetCommandsF[<none>, K, V]
trait CommandsDeps[F, K, V]
class Object
trait Matchable
class Any
class RedisAsyncCommandsF[F, K, V]

Value members

Concrete methods

def bzpopmax(timeout: Long, keys: K*): F[F[Option[(K, (Double, V))]]]
def bzpopmax(timeout: Double, keys: K*): F[F[Option[(K, (Double, V))]]]
def bzpopmin(timeout: Long, keys: K*): F[F[Option[(K, (Double, V))]]]
def bzpopmin(timeout: Double, keys: K*): F[F[Option[(K, (Double, V))]]]
def zadd(key: K, score: Double, member: V): F[F[Long]]
def zadd(key: K, scoredValues: (Double, V)*): F[F[Long]]
def zadd(key: K, zAddArgs: ZAddArgs, score: Double, member: V): F[F[Long]]
def zadd(key: K, zAddArgs: ZAddArgs, scoredValues: (Double, V)*): F[F[Long]]
def zaddincr(key: K, score: Double, member: V): F[F[Option[Double]]]
def zaddincr(key: K, zAddArgs: ZAddArgs, score: Double, member: V): F[F[Option[Double]]]
def zcard(key: K): F[F[Long]]
def zcount(key: K, range: RedisRange[Double]): F[F[Long]]
def zdiff(keys: K*): F[F[Seq[V]]]
def zdiffWithScores(keys: K*): F[F[Seq[(Double, V)]]]
def zdiffstore(destKey: K, srcKeys: K*): F[F[Long]]
def zincrby(key: K, amount: Double, member: V): F[F[Double]]
def zinter(keys: K*): F[F[Seq[V]]]
def zinter(aggregateArgs: ZAggregateArgs, keys: K*): F[F[Seq[V]]]
def zinterWithScores(aggregateArgs: ZAggregateArgs, keys: K*): F[F[Seq[(Double, V)]]]
def zinterWithScores(keys: K*): F[F[Seq[(Double, V)]]]
def zinterstore(destination: K, keys: K*): F[F[Long]]
def zinterstore(destination: K, storeArgs: ZStoreArgs, keys: K*): F[F[Long]]
def zlexcount(key: K, range: RedisRange[V]): F[F[Long]]
def zmscore(key: K, members: V*): F[F[Seq[Option[Double]]]]
def zpopmax(key: K): F[F[Option[(Double, V)]]]
def zpopmax(key: K, count: Long): F[F[Seq[(Double, V)]]]
def zpopmin(key: K): F[F[Option[(Double, V)]]]
def zpopmin(key: K, count: Long): F[F[Seq[(Double, V)]]]
def zrandmember(key: K): F[F[Option[V]]]
def zrandmember(key: K, count: Long): F[F[Seq[V]]]
def zrandmemberWithScores(key: K): F[F[Option[(Double, V)]]]
def zrandmemberWithScores(key: K, count: Long): F[F[Seq[(Double, V)]]]
def zrange(key: K, start: Long, stop: Long): F[F[Seq[V]]]
def zrangeWithScores(key: K, start: Long, stop: Long): F[F[Seq[(Double, V)]]]
def zrangebylex(key: K, range: RedisRange[V]): F[F[Seq[V]]]
def zrangebylex(key: K, range: RedisRange[V], limit: Limit): F[F[Seq[V]]]
def zrangebyscore(key: K, range: RedisRange[Double]): F[F[Seq[V]]]
def zrangebyscore(key: K, range: RedisRange[Double], limit: Limit): F[F[Seq[V]]]
def zrangebyscoreWithScores(key: K, range: RedisRange[Double]): F[F[Seq[(Double, V)]]]
def zrangebyscoreWithScores(key: K, range: RedisRange[Double], limit: Limit): F[F[Seq[(Double, V)]]]
def zrangestorebylex(dstKey: K, srcKey: K, range: RedisRange[V], limit: Limit): F[F[Long]]
def zrangestorebyscore(dstKey: K, srcKey: K, range: RedisRange[Double], limit: Limit): F[F[Long]]
def zrank(key: K, member: V): F[F[Option[Long]]]
def zrem(key: K, members: V*): F[F[Long]]
def zremrangebylex(key: K, range: RedisRange[V]): F[F[Long]]
def zremrangebyrank(key: K, start: Long, stop: Long): F[F[Long]]
def zremrangebyscore(key: K, range: RedisRange[Double]): F[F[Long]]
def zrevrange(key: K, start: Long, stop: Long): F[F[Seq[V]]]
def zrevrangeWithScores(key: K, start: Long, stop: Long): F[F[Seq[(Double, V)]]]
def zrevrangebylex(key: K, range: RedisRange[V]): F[F[Seq[V]]]
def zrevrangebylex(key: K, range: RedisRange[V], limit: Limit): F[F[Seq[V]]]
def zrevrangebyscore(key: K, range: RedisRange[Double]): F[F[Seq[V]]]
def zrevrangebyscore(key: K, range: RedisRange[Double], limit: Limit): F[F[Seq[V]]]
def zrevrangebyscoreWithScores(key: K, range: RedisRange[Double]): F[F[Seq[(Double, V)]]]
def zrevrangebyscoreWithScores(key: K, range: RedisRange[Double], limit: Limit): F[F[Seq[(Double, V)]]]
def zrevrangestorebylex(dstKey: K, srcKey: K, range: RedisRange[V], limit: Limit): F[F[Long]]
def zrevrangestorebyscore(dstKey: K, srcKey: K, range: RedisRange[Double], limit: Limit): F[F[Long]]
def zrevrank(key: K, member: V): F[F[Option[Long]]]
def zscan(key: K): F[F[RedisScanCursor[(Double, V)]]]
def zscan(key: K, scanArgs: ScanArgs): F[F[RedisScanCursor[(Double, V)]]]
def zscan(key: K, scanCursor: ScanCursor, scanArgs: ScanArgs): F[F[RedisScanCursor[(Double, V)]]]
def zscan(key: K, scanCursor: ScanCursor): F[F[RedisScanCursor[(Double, V)]]]
def zscore(key: K, member: V): F[F[Option[Double]]]
def zunion(keys: K*): F[F[Seq[V]]]
def zunion(aggregateArgs: ZAggregateArgs, keys: K*): F[F[Seq[V]]]
def zunionWithScores(aggregateArgs: ZAggregateArgs, keys: K*): F[F[Seq[(Double, V)]]]
def zunionWithScores(keys: K*): F[F[Seq[(Double, V)]]]
def zunionstore(destination: K, keys: K*): F[F[Long]]
def zunionstore(destination: K, storeArgs: ZStoreArgs, keys: K*): F[F[Long]]

Abstract fields

protected
val underlying: RedisSortedSetAsyncCommands[K, V]

Inherited fields

protected
val dispatchHelper: ManualDispatchHelper[K, V]
Inherited from
CommandsDeps

Implicits

Inherited implicits

implicit protected
val _async: Async[F]
Inherited from
CommandsDeps