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

Get the value of a string key.

Example:

let value ← client.get "key"

Equations

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

def LeanRedis.Client.set {τ : Type} [Transport.Transport τ] (client : Client τ) (key value : String) (options : SetOptions := { }) : Std.Internal.IO.Async.Async Bool

Set a string key with optional SET modifiers.

Example:

let stored ← client.set "key" "value"
let storedNx ← client.set "key" "value" { condition? := some .nx }

Equations

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

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

Get multiple string keys with nullable results.

Example:

let values ← client.mGet #["a", "b"]

Equations

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

def LeanRedis.Client.mSet {τ : Type} [Transport.Transport τ] (client : Client τ) (entries : Array (String × String)) : Std.Internal.IO.Async.Async Unit

Set multiple string entries with MSET.

Example:

let _ ← client.mSet #[("a", "1"), ("b", "2")]

Equations

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

def LeanRedis.Client.mSetNx {τ : Type} [Transport.Transport τ] (client : Client τ) (entries : Array (String × String)) : Std.Internal.IO.Async.Async Bool

Set multiple string entries only if all keys are absent.

Example:

let stored ← client.mSetNx #[("a", "1"), ("b", "2")]

Equations

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

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

Get and delete a string key.

Example:

let previous ← client.getDel "key"

Equations

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

def LeanRedis.Client.getEx {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (mode? : Option GetExMode := none) : Std.Internal.IO.Async.Async (Option String)

Get a string key and optionally update its expiration.

Example:

let value ← client.getEx "key" (some <| .persist)

Equations

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

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

Read a substring from a string value.

Example:

let part ← client.getRange "key" 0 4

Equations

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

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

Replace a string value and return the previous one.

Example:

let previous ← client.getSet "key" "next"

Equations

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

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

Overwrite part of a string starting at the given offset.

Example:

let size ← client.setRange "key" 2 "xy"

Equations

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

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

Return the length of a string value.

Example:

let len ← client.strLen "key"

Equations

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

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

Append text to a string value.

Example:

let len ← client.append "key" "suffix"

Equations

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

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

Increment a string integer value by one.

Example:

let value ← client.incr "counter"

Equations

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

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

Increment a string integer value by the given amount.

Example:

let value ← client.incrBy "counter" 5

Equations

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

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

Increment a string numeric value by a decimal amount.

Example:

let value ← client.incrByFloat "score" "1.5"

Equations

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

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

Decrement a string integer value by one.

Example:

let value ← client.decr "counter"

Equations

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

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

Decrement a string integer value by the given amount.

Example:

let value ← client.decrBy "counter" 3

Equations

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

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

Set a string value only if the key does not exist.

Example:

let stored ← client.setNx "key" "value"

Equations

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

def LeanRedis.Client.setEx {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (seconds : UInt64) (value : String) : Std.Internal.IO.Async.Async Unit

Set a string value with a TTL in seconds.

Example:

let _ ← client.setEx "key" 30 "value"

Equations

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

def LeanRedis.Client.pSetEx {τ : Type} [Transport.Transport τ] (client : Client τ) (key : String) (milliseconds : UInt64) (value : String) : Std.Internal.IO.Async.Async Unit

Set a string value with a TTL in milliseconds.

Example:

let _ ← client.pSetEx "key" 500 "value"

Equations

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