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

HashCommands

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

Value members

Concrete methods

def hdel(key: K, fields: K*): F[F[Long]]
def hexists(key: K, field: K): F[F[Boolean]]
def hget(key: K, field: K): F[F[Option[V]]]
def hgetall(key: K): F[F[Map[K, V]]]
def hincrby(key: K, field: K, amount: Long): F[F[Long]]
def hincrbyfloat(key: K, field: K, amount: Double): F[F[Double]]
def hkeys(key: K): F[F[Seq[K]]]
def hlen(key: K): F[F[Long]]
def hmget(key: K, fields: K*): F[F[Seq[(K, Option[V])]]]
def hmset(key: K, map: Map[K, V]): F[F[String]]
def hrandfield(key: K): F[F[Option[K]]]
def hrandfield(key: K, count: Long): F[F[Seq[K]]]
def hrandfieldWithvalues(key: K): F[F[(K, Option[V])]]
def hrandfieldWithvalues(key: K, count: Long): F[F[Seq[(K, Option[V])]]]
def hscan(key: K): F[F[RedisScanCursor[(K, V)]]]
def hscan(key: K, scanArgs: ScanArgs): F[F[RedisScanCursor[(K, V)]]]
def hscan(key: K, scanCursor: ScanCursor, scanArgs: ScanArgs): F[F[RedisScanCursor[(K, V)]]]
def hscan(key: K, scanCursor: ScanCursor): F[F[RedisScanCursor[(K, V)]]]
def hset(key: K, field: K, value: V): F[F[Boolean]]
def hset(key: K, map: Map[K, V]): F[F[Long]]
def hsetnx(key: K, field: K, value: V): F[F[Boolean]]
def hstrlen(key: K, field: K): F[F[Long]]
def hvals(key: K): F[F[Seq[V]]]

Abstract fields

protected
val underlying: RedisHashAsyncCommands[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