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

Add members to a set.

Example:

let added ← client.sAdd "tags" #["lean", "redis"]

Equations

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

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

Remove members from a set.

Example:

let removed ← client.sRem "tags" #["redis"]

Equations

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

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

Return the cardinality of a set.

Example:

let size ← client.sCard "tags"

Equations

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

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

Check whether a member belongs to a set.

Example:

let present ← client.sIsMember "tags" "lean"

Equations

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

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

Check multiple members against a set.

Example:

let present ← client.sMIsMember "tags" #["lean", "redis"]

Equations

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

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

Return all members of a set.

Example:

let members ← client.sMembers "tags"

Equations

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

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

Pop one random member from a set.

Example:

let member ← client.sPop "tags"

Equations

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

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

Pop multiple random members from a set.

Example:

let members ← client.sPopMany "tags" 2

Equations

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

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

Return one random set member without removing it.

Example:

let member ← client.sRandMember "tags"

Equations

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

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

Return random set members without removing them.

Example:

let members ← client.sRandMembers "tags" 2

Equations

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

def LeanRedis.Client.sMove {τ : Type} [Transport.Transport τ] (client : Client τ) (source destination member : String) : Std.Internal.IO.Async.Async Bool

Move a set member to another set.

Example:

let moved ← client.sMove "todo" "done" "task:1"

Equations

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

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

Return the difference of multiple sets.

Example:

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

Equations

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

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

Store the difference of multiple sets into a destination key.

Example:

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

Equations

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

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

Return the intersection of multiple sets.

Example:

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

Equations

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

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

Return the intersection cardinality of multiple sets.

Example:

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

Equations

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

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

Store the intersection of multiple sets into a destination key.

Example:

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

Equations

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

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

Return the union of multiple sets.

Example:

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

Equations

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

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

Store the union of multiple sets into a destination key.

Example:

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

Equations

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

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

Scan a set incrementally.

Example:

let page ← client.sScan "tags" 0

Equations

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