use the same prompt for strings

Author: Niennienzz

docs/command-reference/strings/append.md

@@ -40,11 +40,11 @@ APPEND key value
 Appending a value to an existing key:
 
 ```shell
-dragonfly> SET mystring "Hello"
+dragonfly$> SET mystring "Hello"
 OK
-dragonfly> APPEND mystring " World"
+dragonfly$> APPEND mystring " World"
 (integer) 11
-dragonfly> GET mystring
+dragonfly$> GET mystring
 "Hello World"
 ```
 
@@ -53,11 +53,11 @@ dragonfly> GET mystring
 Accumulating log entries for a simple logging mechanism:
 
 ```shell
-dragonfly> APPEND log "2023-07-26 10:00:00 - User login\n"
+dragonfly$> APPEND log "2023-07-26 10:00:00 - User login\n"
 (integer) 33
-dragonfly> APPEND log "2023-07-26 10:05:00 - User logout\n"
+dragonfly$> APPEND log "2023-07-26 10:05:00 - User logout\n"
 (integer) 66
-dragonfly> GET log
+dragonfly$> GET log
 "2023-07-26 10:00:00 - User login\n2023-07-26 10:05:00 - User logout\n"
 ```
 
@@ -66,13 +66,13 @@ dragonfly> GET log
 Building a configuration file or script incrementally:
 
 ```shell
-dragonfly> APPEND config "server {\n"
+dragonfly$> APPEND config "server {\n"
 (integer) 9
-dragonfly> APPEND config "  listen 80;\n"
+dragonfly$> APPEND config "  listen 80;\n"
 (integer) 22
-dragonfly> APPEND config "}\n"
+dragonfly$> APPEND config "}\n"
 (integer) 24
-dragonfly> GET config
+dragonfly$> GET config
 "server {\n  listen 80;\n}\n"
 ```
 
@@ -86,9 +86,9 @@ dragonfly> GET config
 - Appending to a key that holds a non-string value can result in an error. Always ensure the data type compatibility.
 
   ```shell
-  dragonfly> LPUSH mylist "item"
+  dragonfly$> LPUSH mylist "item"
   (integer) 1
-  dragonfly> APPEND mylist "string"
+  dragonfly$> APPEND mylist "string"
   (error) WRONGTYPE Operation against a key holding the wrong kind of value
   ```
 

docs/command-reference/strings/bitcount.md

@@ -42,9 +42,9 @@ Count all set bits in a string:
 # String: example
 # Hex:    0x65     0x78     0x61     0x6d     0x70     0x6c     0x65
 # Binary: 01100101 01111000 01100001 01101101 01110000 01101100 01100101
-dragonfly> SET mykey "example"
+dragonfly$> SET mykey "example"
 OK
-dragonfly> BITCOUNT mykey
+dragonfly$> BITCOUNT mykey
 (integer) 27
 ```
 
@@ -56,9 +56,9 @@ Count bits from the second to the fourth byte:
 # String: example
 # Hex:    0x65     0x78     0x61     0x6d     0x70     0x6c     0x65
 # Binary: 01100101 01111000 01100001 01101101 01110000 01101100 01100101
-dragonfly> SET mykey "example"
+dragonfly$> SET mykey "example"
 OK
-dragonfly> BITCOUNT mykey 1 3
+dragonfly$> BITCOUNT mykey 1 3
 (integer) 12
 ```
 
@@ -69,9 +69,9 @@ Imagine you have a feature flag system where each bit represents whether a featu
 ```shell
 # Hex:    0x01     0x02     0x04
 # Binary: 00000001 00000010 00000100
-dragonfly> SET features "\x01\x02\x04"
+dragonfly$> SET features "\x01\x02\x04"
 OK
-dragonfly> BITCOUNT features
+dragonfly$> BITCOUNT features
 (integer) 3  # Three features are enabled across different users.
 ```
 

docs/command-reference/strings/bitfield.md

@@ -54,9 +54,9 @@ BITFIELD key [GET type offset]
 ### Basic Example
 
 ```shell
-dragonfly> BITFIELD mykey SET u8 0 100
+dragonfly$> BITFIELD mykey SET u8 0 100
 1) (integer) 0
-dragonfly> BITFIELD mykey GET u8 0
+dragonfly$> BITFIELD mykey GET u8 0
 1) (integer) 100
 ```
 
@@ -65,13 +65,13 @@ dragonfly> BITFIELD mykey GET u8 0
 Using `BITFIELD` to implement an 8-bit counter:
 
 ```shell
-dragonfly> BITFIELD mycounter INCRBY u8 0 1
+dragonfly$> BITFIELD mycounter INCRBY u8 0 1
 1) (integer) 1
-dragonfly> BITFIELD mycounter INCRBY u8 0 1
+dragonfly$> BITFIELD mycounter INCRBY u8 0 1
 1) (integer) 2
-dragonfly> BITFIELD mycounter INCRBY u8 0 253
+dragonfly$> BITFIELD mycounter INCRBY u8 0 253
 1) (integer) 255
-dragonfly> BITFIELD mycounter INCRBY u8 0 1
+dragonfly$> BITFIELD mycounter INCRBY u8 0 1
 1) (integer) 0  # Overflow occurs as it wraps around.
 ```
 
@@ -80,13 +80,13 @@ dragonfly> BITFIELD mycounter INCRBY u8 0 1
 Using `BITFIELD` to manage multiple flags within a single key:
 
 ```shell
-dragonfly> BITFIELD user_flags SET u1 0 1
+dragonfly$> BITFIELD user_flags SET u1 0 1
 1) (integer) 0
-dragonfly> BITFIELD user_flags SET u1 1 1
+dragonfly$> BITFIELD user_flags SET u1 1 1
 1) (integer) 0
-dragonfly> BITFIELD user_flags GET u1 0
+dragonfly$> BITFIELD user_flags GET u1 0
 1) (integer) 1
-dragonfly> BITFIELD user_flags GET u1 1
+dragonfly$> BITFIELD user_flags GET u1 1
 1) (integer) 1
 ```
 

docs/command-reference/strings/bitfield_ro.md

@@ -41,9 +41,9 @@ The command returns an array of integers, where each integer corresponds to the
 Retrieve an unsigned 8-bit integer (starting at offset `0`) and a signed 16-bit integer (starting at offset `8`).
 
 ```shell
-dragonfly> SET mystring "\x01\x02\x03"
+dragonfly$> SET mystring "\x01\x02\x03"
 OK
-dragonfly> BITFIELD_RO mystring GET u8 0 GET i16 8
+dragonfly$> BITFIELD_RO mystring GET u8 0 GET i16 8
 1) (integer) 1
 2) (integer) 515
 ```
@@ -54,9 +54,9 @@ In this example, we extract multiple bitfields from a single string.
 This demonstrates how to handle different offsets and encodings.
 
 ```shell
-dragonfly> SET mystring "\xFF\xFE\xFD"
+dragonfly$> SET mystring "\xFF\xFE\xFD"
 OK
-dragonfly> BITFIELD_RO mystring GET u8 0 GET u8 8 GET i16 16
+dragonfly$> BITFIELD_RO mystring GET u8 0 GET u8 8 GET i16 16
 1) (integer) 255
 2) (integer) 254
 3) (integer) -3
@@ -67,9 +67,9 @@ dragonfly> BITFIELD_RO mystring GET u8 0 GET u8 8 GET i16 16
 Extracting larger bitfields, such as 32-bit integers, to demonstrate handling of wider data.
 
 ```shell
-dragonfly> SET mystring "\x00\x00\x00\x01\x00\x00\x00\x02"
+dragonfly$> SET mystring "\x00\x00\x00\x01\x00\x00\x00\x02"
 OK
-dragonfly> BITFIELD_RO mystring GET u32 0 GET u32 32
+dragonfly$> BITFIELD_RO mystring GET u32 0 GET u32 32
 1) (integer) 1
 2) (integer) 2
 ```

docs/command-reference/strings/bitop.md

@@ -40,13 +40,13 @@ Returns the size of the string stored in the destination key, measured in bytes.
 Performing a basic bitwise `AND` operation between two keys:
 
 ```shell
-dragonfly> SET key1 "foobar"
+dragonfly$> SET key1 "foobar"
 OK
-dragonfly> SET key2 "abcdef"
+dragonfly$> SET key2 "abcdef"
 OK
-dragonfly> BITOP AND result key1 key2
+dragonfly$> BITOP AND result key1 key2
 (integer) 6
-dragonfly> GET result
+dragonfly$> GET result
 "\x60\x60\x04\x00\x00\x00"
 ```
 
@@ -55,15 +55,15 @@ dragonfly> GET result
 Combining three keys using the `OR` operation:
 
 ```shell
-dragonfly> SET key1 "\x01"
+dragonfly$> SET key1 "\x01"
 OK
-dragonfly> SET key2 "\x02"
+dragonfly$> SET key2 "\x02"
 OK
-dragonfly> SET key3 "\x03"
+dragonfly$> SET key3 "\x03"
 OK
-dragonfly> BITOP OR result key1 key2 key3
+dragonfly$> BITOP OR result key1 key2 key3
 (integer) 1
-dragonfly> GET result
+dragonfly$> GET result
 "\x03"
 ```
 
@@ -72,13 +72,13 @@ dragonfly> GET result
 Using the `XOR` operation to combine two keys:
 
 ```shell
-dragonfly> SET key1 "\x0F"
+dragonfly$> SET key1 "\x0F"
 OK
-dragonfly> SET key2 "\xF0"
+dragonfly$> SET key2 "\xF0"
 OK
-dragonfly> BITOP XOR result key1 key2
+dragonfly$> BITOP XOR result key1 key2
 (integer) 1
-dragonfly> GET result
+dragonfly$> GET result
 "\xFF"
 ```
 
@@ -87,11 +87,11 @@ dragonfly> GET result
 Performing the `NOT` operation on a single key:
 
 ```shell
-dragonfly> SET key1 "\xAA"  # 10101010 in binary
+dragonfly$> SET key1 "\xAA"  # 10101010 in binary
 OK
-dragonfly> BITOP NOT result key1
+dragonfly$> BITOP NOT result key1
 (integer) 1
-dragonfly> GET result
+dragonfly$> GET result
 "\x55"  # 01010101 in binary (inverted bits)
 ```
 

docs/command-reference/strings/bitpos.md

@@ -45,9 +45,9 @@ In this example, we will find the first occurrence of `1` in the string:
 # String: example
 # Hex:    0x65     0x78     0x61     0x6d     0x70     0x6c     0x65
 # Binary: 01100101 01111000 01100001 01101101 01110000 01101100 01100101
-dragonfly> SET mykey "example"
+dragonfly$> SET mykey "example"
 OK
-dragonfly> BITPOS mykey 1
+dragonfly$> BITPOS mykey 1
 (integer) 1
 ```
 
@@ -58,9 +58,9 @@ The first occurrence of a `1` happens at bit position 1. (Remember, positions ar
 Similarly, we can find the first occurrence of a `0` bit in the string:
 
 ```shell
-dragonfly> SET mykey "example"
+dragonfly$> SET mykey "example"
 OK
-dragonfly> BITPOS mykey 0
+dragonfly$> BITPOS mykey 0
 (integer) 0
 ```
 
@@ -74,9 +74,9 @@ We can specify a search range within bytes to limit the search. The following ex
 # String: example
 # Hex:    0x65     0x78     0x61     0x6d     0x70     0x6c     0x65
 # Binary: 01100101 01111000 01100001 01101101 01110000 01101100 01100101
-dragonfly> SET mykey "example"
+dragonfly$> SET mykey "example"
 OK
-dragonfly> BITPOS mykey 1 1 3
+dragonfly$> BITPOS mykey 1 1 3
 (integer) 9
 ```
 
@@ -89,9 +89,9 @@ You can also use `BITPOS` in a system where flags are represented by bits within
 ```shell
 # Example binary string: 0x00 0x04 0x80
 # Binary:                00000000 00000100 10000000
-dragonfly> SET flags "\x00\x04\x80"
+dragonfly$> SET flags "\x00\x04\x80"
 OK
-dragonfly> BITPOS flags 1
+dragonfly$> BITPOS flags 1
 (integer) 13
 ```
 

docs/command-reference/strings/cl.throttle.md

@@ -34,13 +34,13 @@ An [array](https://redis.io/docs/reference/protocol-spec/#arrays) of 5 integers
 ## Examples
 
 ```shell
-dragonfly> CL.THROTTLE USER1 0 1 10 1
+dragonfly$> CL.THROTTLE USER1 0 1 10 1
 1) (integer) 0
 2) (integer) 1
 3) (integer) 0
 4) (integer) -1
 5) (integer) 11
-dragonfly> CL.THROTTLE USER1 0 1 10 1
+dragonfly$> CL.THROTTLE USER1 0 1 10 1
 1) (integer) 1
 2) (integer) 1
 3) (integer) 0

docs/command-reference/strings/decr.md

@@ -37,9 +37,9 @@ The command returns the value of the key after the decrement operation.
 Decrement the value of a key:
 
 ```shell
-dragonfly> SET mycounter 5
+dragonfly$> SET mycounter 5
 OK
-dragonfly> DECR mycounter
+dragonfly$> DECR mycounter
 (integer) 4
 ```
 
@@ -50,7 +50,7 @@ In this example, the value of `mycounter` is decremented from `5` to `4`.
 If the key does not exist, `DECR` initializes the value to `0` before performing the decrement:
 
 ```shell
-dragonfly> DECR not_yet_set
+dragonfly$> DECR not_yet_set
 (integer) -1
 ```
 
@@ -61,15 +61,15 @@ Here, since `not_yet_set` did not previously exist, it is initialized to `0` and
 You can easily implement a countdown timer using `DECR`, which decrements until a limit is reached:
 
 ```shell
-dragonfly> SET countdown 10
+dragonfly$> SET countdown 10
 OK
-dragonfly> DECR countdown
+dragonfly$> DECR countdown
 (integer) 9
-dragonfly> DECR countdown
+dragonfly$> DECR countdown
 (integer) 8
-dragonfly> DECR countdown
+dragonfly$> DECR countdown
 (integer) 7
-dragonfly> DECR countdown
+dragonfly$> DECR countdown
 (integer) 6
 ```
 
@@ -85,9 +85,9 @@ Each `DECR` call reduces the value by `1`, simulating a countdown from `10` to `
 - Using `DECR` on a key that holds a non-integer, such as a string that cannot be parsed as a number. This will result in an error.
 
 ```shell
-dragonfly> SET mykey "abc"
+dragonfly$> SET mykey "abc"
 OK
-dragonfly> DECR mykey
+dragonfly$> DECR mykey
 (error) ERR value is not an integer or out of range
 ```