def LeanRedis.Client.zAdd {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (entries : Array SortedSetEntry) : Std.Internal.IO.Async.Async Int

Add scored members to a sorted set.

Example:

let added ← client.zAdd "scores" #[{ score := "10", member := "alice" }]

Equations

• client.zAdd key entries = do let reply ← client.execute (LeanRedis.Command.zAdd key entries).request liftM ((LeanRedis.Command.zAdd key entries).decode reply)

def LeanRedis.Client.zRem {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (members : Array String) : Std.Internal.IO.Async.Async Int

Remove members from a sorted set.

Example:

let removed ← client.zRem "scores" #["alice"]

Equations

• client.zRem key members = do let reply ← client.execute (LeanRedis.Command.zRem key members).request liftM ((LeanRedis.Command.zRem key members).decode reply)

def LeanRedis.Client.zCard {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) : Std.Internal.IO.Async.Async Int

Return the cardinality of a sorted set.

Example:

let size ← client.zCard "scores"

Equations

• client.zCard key = do let reply ← client.execute (LeanRedis.Command.zCard key).request liftM ((LeanRedis.Command.zCard key).decode reply)

def LeanRedis.Client.zScore {τ : Type} [Transport.Transport τ] (client : Client τ) (key member : String) : Std.Internal.IO.Async.Async (Option String)

Return the score of a sorted-set member.

Example:

let score ← client.zScore "scores" "alice"

Equations

• client.zScore key member = do let reply ← client.execute (LeanRedis.Command.zScore key member).request liftM ((LeanRedis.Command.zScore key member).decode reply)

def LeanRedis.Client.zMScore {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (members : Array String) : Std.Internal.IO.Async.Async (Array (Option String))

Return the scores for multiple sorted-set members.

Example:

let scores ← client.zMScore "scores" #["alice", "bob"]

Equations

• client.zMScore key members = do let reply ← client.execute (LeanRedis.Command.zMScore key members).request liftM ((LeanRedis.Command.zMScore key members).decode reply)

def LeanRedis.Client.zRank {τ : Type} [Transport.Transport τ] (client : Client τ) (key member : String) : Std.Internal.IO.Async.Async (Option Int)

Return the rank of a sorted-set member.

Example:

let rank ← client.zRank "scores" "alice"

Equations

• client.zRank key member = do let reply ← client.execute (LeanRedis.Command.zRank key member).request liftM ((LeanRedis.Command.zRank key member).decode reply)

def LeanRedis.Client.zRevRank {τ : Type} [Transport.Transport τ] (client : Client τ) (key member : String) : Std.Internal.IO.Async.Async (Option Int)

Return the reverse rank of a sorted-set member.

Example:

let rank ← client.zRevRank "scores" "alice"

Equations

• client.zRevRank key member = do let reply ← client.execute (LeanRedis.Command.zRevRank key member).request liftM ((LeanRedis.Command.zRevRank key member).decode reply)

def LeanRedis.Client.zRange {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (start stop : Int) : Std.Internal.IO.Async.Async (Array String)

Return sorted-set members in score order by rank range.

Example:

let members ← client.zRange "scores" 0 (-1)

Equations

• client.zRange key start stop = do let reply ← client.execute (LeanRedis.Command.zRange key start stop).request liftM ((LeanRedis.Command.zRange key start stop).decode reply)

def LeanRedis.Client.zRangeWithScores {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (start stop : Int) : Std.Internal.IO.Async.Async (Array SortedSetEntry)

Return sorted-set members with scores by rank range.

Example:

let entries ← client.zRangeWithScores "scores" 0 (-1)

Equations

• One or more equations did not get rendered due to their size.

def LeanRedis.Client.zRevRange {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (start stop : Int) : Std.Internal.IO.Async.Async (Array String)

Return sorted-set members in reverse score order by rank range.

Example:

let members ← client.zRevRange "scores" 0 (-1)

Equations

• client.zRevRange key start stop = do let reply ← client.execute (LeanRedis.Command.zRevRange key start stop).request liftM ((LeanRedis.Command.zRevRange key start stop).decode reply)

def LeanRedis.Client.zRevRangeWithScores {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (start stop : Int) : Std.Internal.IO.Async.Async (Array SortedSetEntry)

Return sorted-set members with scores in reverse score order.

Example:

let entries ← client.zRevRangeWithScores "scores" 0 (-1)

Equations

• One or more equations did not get rendered due to their size.

def LeanRedis.Client.zRangeByScore {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async (Array String)

Return sorted-set members within a score range.

Example:

let members ← client.zRangeByScore "scores" "0" "100"

Equations

• client.zRangeByScore key min max = do let reply ← client.execute (LeanRedis.Command.zRangeByScore key min max).request liftM ((LeanRedis.Command.zRangeByScore key min max).decode reply)

def LeanRedis.Client.zRangeByScoreWithScores {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async (Array SortedSetEntry)

Return sorted-set members with scores within a score range.

Example:

let entries ← client.zRangeByScoreWithScores "scores" "0" "100"

Equations

• One or more equations did not get rendered due to their size.

def LeanRedis.Client.zRevRangeByScore {τ : Type} [Transport.Transport τ] (client : Client τ) (key max min : String) : Std.Internal.IO.Async.Async (Array String)

Return sorted-set members within a reverse score range.

Example:

let members ← client.zRevRangeByScore "scores" "100" "0"

Equations

• client.zRevRangeByScore key max min = do let reply ← client.execute (LeanRedis.Command.zRevRangeByScore key max min).request liftM ((LeanRedis.Command.zRevRangeByScore key max min).decode reply)

def LeanRedis.Client.zRevRangeByScoreWithScores {τ : Type} [Transport.Transport τ] (client : Client τ) (key max min : String) : Std.Internal.IO.Async.Async (Array SortedSetEntry)

Return sorted-set members with scores within a reverse score range.

Example:

let entries ← client.zRevRangeByScoreWithScores "scores" "100" "0"

Equations

• One or more equations did not get rendered due to their size.

def LeanRedis.Client.zRangeByLex {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async (Array String)

Return sorted-set members within a lexicographic range.

Example:

let members ← client.zRangeByLex "names" "-" "+"

Equations

• client.zRangeByLex key min max = do let reply ← client.execute (LeanRedis.Command.zRangeByLex key min max).request liftM ((LeanRedis.Command.zRangeByLex key min max).decode reply)

def LeanRedis.Client.zRevRangeByLex {τ : Type} [Transport.Transport τ] (client : Client τ) (key max min : String) : Std.Internal.IO.Async.Async (Array String)

Return sorted-set members within a reverse lexicographic range.

Example:

let members ← client.zRevRangeByLex "names" "+" "-"

Equations

• client.zRevRangeByLex key max min = do let reply ← client.execute (LeanRedis.Command.zRevRangeByLex key max min).request liftM ((LeanRedis.Command.zRevRangeByLex key max min).decode reply)

def LeanRedis.Client.zCount {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async Int

Count members within a score range.

Example:

let count ← client.zCount "scores" "0" "100"

Equations

• client.zCount key min max = do let reply ← client.execute (LeanRedis.Command.zCount key min max).request liftM ((LeanRedis.Command.zCount key min max).decode reply)

def LeanRedis.Client.zLexCount {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async Int

Count members within a lexicographic range.

Example:

let count ← client.zLexCount "names" "-" "+"

Equations

• client.zLexCount key min max = do let reply ← client.execute (LeanRedis.Command.zLexCount key min max).request liftM ((LeanRedis.Command.zLexCount key min max).decode reply)

def LeanRedis.Client.zRemRangeByRank {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (start stop : Int) : Std.Internal.IO.Async.Async Int

Remove members by rank range.

Example:

let removed ← client.zRemRangeByRank "scores" 0 1

Equations

• One or more equations did not get rendered due to their size.

def LeanRedis.Client.zRemRangeByScore {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async Int

Remove members by score range.

Example:

let removed ← client.zRemRangeByScore "scores" "0" "10"

Equations

• client.zRemRangeByScore key min max = do let reply ← client.execute (LeanRedis.Command.zRemRangeByScore key min max).request liftM ((LeanRedis.Command.zRemRangeByScore key min max).decode reply)

def LeanRedis.Client.zRemRangeByLex {τ : Type} [Transport.Transport τ] (client : Client τ) (key min max : String) : Std.Internal.IO.Async.Async Int

Remove members by lexicographic range.

Example:

let removed ← client.zRemRangeByLex "names" "-" "+"

Equations

• client.zRemRangeByLex key min max = do let reply ← client.execute (LeanRedis.Command.zRemRangeByLex key min max).request liftM ((LeanRedis.Command.zRemRangeByLex key min max).decode reply)

def LeanRedis.Client.zIncrBy {τ : Type} [Transport.Transport τ] (client : Client τ) (key increment member : String) : Std.Internal.IO.Async.Async String

Increment a sorted-set member score.

Example:

let score ← client.zIncrBy "scores" "1.5" "alice"

Equations

• client.zIncrBy key increment member = do let reply ← client.execute (LeanRedis.Command.zIncrBy key increment member).request liftM ((LeanRedis.Command.zIncrBy key increment member).decode reply)

def LeanRedis.Client.zRandMember {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) : Std.Internal.IO.Async.Async (Option String)

Return one random sorted-set member without removing it.

Example:

let member ← client.zRandMember "scores"

Equations

• client.zRandMember key = do let reply ← client.execute (LeanRedis.Command.zRandMember key).request liftM ((LeanRedis.Command.zRandMember key).decode reply)

def LeanRedis.Client.zRandMembers {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (count : Int) : Std.Internal.IO.Async.Async (Array String)

Return random sorted-set members without removing them.

Example:

let members ← client.zRandMembers "scores" 2

Equations

• client.zRandMembers key count = do let reply ← client.execute (LeanRedis.Command.zRandMembers key count).request liftM ((LeanRedis.Command.zRandMembers key count).decode reply)

def LeanRedis.Client.zRandMembersWithScores {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (count : Int) : Std.Internal.IO.Async.Async (Array SortedSetEntry)

Return random sorted-set members with scores.

Example:

let entries ← client.zRandMembersWithScores "scores" 2

Equations

• One or more equations did not get rendered due to their size.

def LeanRedis.Client.zDiff {τ : Type} [Transport.Transport τ] (client : Client τ) (keys : Array String) : Std.Internal.IO.Async.Async (Array String)

Return the difference of multiple sorted sets.

Example:

let members ← client.zDiff #["a", "b"]

Equations

• client.zDiff keys = do let reply ← client.execute (LeanRedis.Command.zDiff keys).request liftM ((LeanRedis.Command.zDiff keys).decode reply)

def LeanRedis.Client.zDiffStore {τ : Type} [Transport.Transport τ] (client : Client τ) (destination : String) (keys : Array String) : Std.Internal.IO.Async.Async Int

Store the difference of multiple sorted sets into a destination key.

Example:

let size ← client.zDiffStore "result" #["a", "b"]

Equations

• client.zDiffStore destination keys = do let reply ← client.execute (LeanRedis.Command.zDiffStore destination keys).request liftM ((LeanRedis.Command.zDiffStore destination keys).decode reply)

def LeanRedis.Client.zInter {τ : Type} [Transport.Transport τ] (client : Client τ) (keys : Array String) : Std.Internal.IO.Async.Async (Array String)

Return the intersection of multiple sorted sets.

Example:

let members ← client.zInter #["a", "b"]

Equations

• client.zInter keys = do let reply ← client.execute (LeanRedis.Command.zInter keys).request liftM ((LeanRedis.Command.zInter keys).decode reply)

def LeanRedis.Client.zInterCard {τ : Type} [Transport.Transport τ] (client : Client τ) (keys : Array String) : Std.Internal.IO.Async.Async Int

Return the intersection cardinality of multiple sorted sets.

Example:

let size ← client.zInterCard #["a", "b"]

Equations

• client.zInterCard keys = do let reply ← client.execute (LeanRedis.Command.zInterCard keys).request liftM ((LeanRedis.Command.zInterCard keys).decode reply)

def LeanRedis.Client.zInterStore {τ : Type} [Transport.Transport τ] (client : Client τ) (destination : String) (keys : Array String) : Std.Internal.IO.Async.Async Int

Store the intersection of multiple sorted sets into a destination key.

Example:

let size ← client.zInterStore "result" #["a", "b"]

Equations

• client.zInterStore destination keys = do let reply ← client.execute (LeanRedis.Command.zInterStore destination keys).request liftM ((LeanRedis.Command.zInterStore destination keys).decode reply)

def LeanRedis.Client.zUnion {τ : Type} [Transport.Transport τ] (client : Client τ) (keys : Array String) : Std.Internal.IO.Async.Async (Array String)

Return the union of multiple sorted sets.

Example:

let members ← client.zUnion #["a", "b"]

Equations

• client.zUnion keys = do let reply ← client.execute (LeanRedis.Command.zUnion keys).request liftM ((LeanRedis.Command.zUnion keys).decode reply)

def LeanRedis.Client.zUnionStore {τ : Type} [Transport.Transport τ] (client : Client τ) (destination : String) (keys : Array String) : Std.Internal.IO.Async.Async Int

Store the union of multiple sorted sets into a destination key.

Example:

let size ← client.zUnionStore "result" #["a", "b"]

Equations

• client.zUnionStore destination keys = do let reply ← client.execute (LeanRedis.Command.zUnionStore destination keys).request liftM ((LeanRedis.Command.zUnionStore destination keys).decode reply)

def LeanRedis.Client.zScan {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (cursor : UInt64) (options : ZScanOptions := { }) : Std.Internal.IO.Async.Async SortedSetScanResult

Scan a sorted set incrementally.

Example:

let page ← client.zScan "scores" 0

Equations

• client.zScan key cursor options = do let reply ← client.execute (LeanRedis.Command.zScan key cursor options).request liftM ((LeanRedis.Command.zScan key cursor options).decode reply)