$redis->set('foo', 'hello, world');
echo $redis->get('foo');

hello, world

$redis->setex('foo', 2, 'hello, world');
echo $redis->get('foo'), PHP_EOL;
sleep(3);
echo ($redis->get('foo') ?: 'Not Found'), PHP_EOL;

hello, world
Not Found

$redis->setex('foo', 2, 'hello, world');
echo $redis->get('foo'), PHP_EOL;
sleep(3);
echo ($redis->get('foo') ?: 'Not Found'), PHP_EOL;

hello, world
Not Found

if(!$redis->get('api_debouncer')){
    $redis->set('api_debouncer', true, [
        'nx',
        'ex' => 2,
    ]);

    // do api stuff...
}

$quicklock = new class($redis) {
    public function __construct(private Redis $redis){}

    public function lock($name): string
    {
        $random_bytes = \random_bytes(16);
        $this->redis->set('lock.' . $name, $random_bytes, [
            'nx',
            'ex' => 2,
        ]);
        return $random_bytes;
    }

    public function unlock($name, $key = null): void
    {
        $lock = $this->redis->get('lock.' . $name);
        if (!$lock || $lock === $key) {
            $this->redis->del('lock.' . $name);
        }
    }
};

class CheckZipCode
{
    public function __construct(private Redis $redis)
    {
    }

    public function add(string $zip_code): void
    {
        $key = substr($zip_code, 0, 5);
        $offset = (int)substr($zip_code, 5, 4);
        $this->redis->setBit($key, $offset, 1);
    }

    public function check(string $zip_code): bool
    {
        $key = substr($zip_code, 0, 5);
        $offset = (int)substr($zip_code, 5, 4);
        return $this->redis->getBit($key, $offset);
    }
}

// Set a field on a hash
$redis->hSet('import:33342', 'job_id', 12345); // 1
$redis->hSet('import:33342', 'import_count', 0); // 1

// Set multiple fields on a hash
$redis->hMSet('import:73723', ['job_id' => 234323, 'import_count' => 0]); // true

// Get the value of a hash field
$redis->hGet('import:73723', 'job_id'); // '234323'

// Get all the fields/values of a hash -- caution: order is not guaranteed.
$redis->hGetAll('import:73723'); // [ 'import_count' => '0', 'job_id' => '234323']

// Increment the value of a hash field 
$redis->hIncrBy('import:73723', 'import_count', 1); // 1

// Add values to either side of the list
$redis->lPush('queued_email', 8976454); // 1 (length of list)
$redis->rPush('queued_email', 3423432); // 2
$redis->rPush('queued_email', 3423432); // 3 duplicates are ok
$redis->rPush('queued_email', 5675456); // 4
$redis->rPush('queued_email', 3423411); // 5

// Get the length of the list
$redis->llen('queued_email'); // 5

// Remove from either side of the list
$redis->lPop('queued_email'); // '8976454'
$redis->rPop('queued_email'); // '3423411'

// Remove from either side while blocking for up to 30 seconds
$redis->blPop('queued_email', 30); // '3423432'
$redis->brPop('queued_email', 30); // '5675456'

// Remove from right side of one list and push it onto a different list.
$redis->rpoplpush('queued_contacts', 'dequeued_email'); // 3423432
$redis->brpoplpush(queued_contacts, dequeued_email, 30); // false

$redis->sAdd('emails', 'andy@example.com'); // 1
$redis->sAdd('emails', 'kevin@example.com'); // 1
$redis->sAdd('emails', 'kevin@example.com'); // 0 (already exists)

// Add more items to the set using an Array
$redis->sAddArray('emails', ['rachel@example.com', 'jc@example.com']); // true

// Get the cardinality (count) of a set
$redis->sCard('emails'); // 5

// Check if an element is a member of the set
$redis->sIsMember('emails', 'kevin@example.com'); // true
$redis->sIsMember('emails', 'jack@example.com'); // false

// Get all members of the set
$redis->sMembers('emails'); // [ array containing all the emails ]

// Get the intersection of multiple sets
$redis->sInter('emails', 'other_emails');
$redis->sInterStore('inter_list', 'emails', 'other_emails');

// Get the union of multiple sets
$redis->sUnion('emails', 'other_emails');
$redis->sUnionStore('union_list', 'emails', 'other_emails');

// Get the difference of multiple sets
$redis->sDiff('emails', 'other_emails');
$redis->sDiffStore('diff_list', 'emails', 'other_emails');

class CombinedPosts
{
    public function __construct(private Redis $redis) {}

    public function add(int $user_id, int $post_id): bool
    {
        $personal_key = "user:{$user_id}:posts";
        return (bool)$this->redis->sAdd($personal_key, $post_id);
    }

    public function check(int $user_id, int $team_id, int $post_id): bool
    {
        $personal_key = "user:{$user_id}:posts";
        $team_key = "team:{$team_id}:posts";
        $union_key = "temp:allposts:{$user_id}";
        $pipe = $this->redis->multi();
        $pipe->sInterStore($union_key, $personal_key, $team_key);
        $pipe->sIsMember($union_key, $post_id);
        $pipe->del($union_key);
        $result = $pipe->exec();
        return (bool)$result[1];
    }
}

class RedisRateLimit
{
    public function __construct(private Redis $redis) {}

    public function check(string $request_source_id, $requests_per_minute = 120): void
    {
        $key = "ratelimit:" . $request_source_id;

        $pipe = $this->redis->multi(Redis::PIPELINE);
        $pipe->zAdd($key, time(), bin2hex(\random_bytes(16)));
        $pipe->expire($key, 60);
        $pipe->zRemRangeByScore($key, 0, time() - 60);
        $pipe->zCard($key);
        $pipe_results = $pipe->exec(); // [1, true, 0, 1]
        if ($pipe_results[3] > $requests_per_minute) {
            throw new RateLimitExceeded();
        }
    }
}