Type Members

1.  trait AllBListProtocol extends BListProtocol with BListProtocolExtra
2.  trait AllHashProtocol extends HashProtocol with HashProtocolExtra
3.  trait AllHyperLogLogProtocol extends HyperLogLogProtocol with HyperLogLogProtocolExtra
4.  trait AllKeyProtocol extends KeyProtocol with KeyProtocolExtra
5.  trait AllListProtocol extends ListProtocol with ListProtocolExtra
6.  trait AllSetProtocol extends SetProtocol with SetProtocolExtra
7.  trait AllSortedSetProtocol extends SortedSetProtocol with SortedSetProtocolExtra
8.  trait AllStringProtocol extends StringProtocol with StringProtocolExtra
9.  sealed trait Array extends RESP

   RESP Arrays

   RESP Arrays

   There can be 2 cases:

   • nil arrays, where the length is -1 and no array element is present
   • actual (non-nil) arrays, where the length is >= 0

   Non-nil Arrays can be constructed using the RESPBuilders#arr(xs: Seq[RESP]) method.

   Example:

   1. import laserdisc.protocol.RESP._
      
      val nonNilArray: NonNilArray             = arr(Vector(str("hello"), str("world")))
      val guaranteedNonEmptyArray: NonNilArray = arr(str("hello"), str("world"))
      val emptyArray: NonNilArray              = arr(Vector.empty)
      val nilArray: NilArray                   = nilArray

   Note

   A forwarder for nil is present too and represented using the final vals RESPBuilders.nilArray

   ,

   RESPBuilders#arr(one: RESP, rest: RESP*) is an overload which supports the creation of guaranteed non-empty sequences only. This is achieved through the usage of one fixed parameter followed by a var-arg of the same

10.  sealed trait AtLeastN[L <: HList, N <: Nat, A] extends DepFn0 with Serializable

    This type-class serves two purposes:

    This type-class serves two purposes:

    • as a witness of the requirement for a HList L to only contain repeated (N or more) types that are subtypes of some given type A
    • as a higher-ranked no-args function that allows the caller to retrieve the effective length of the HList at the value level.

    L

    The HList that will be verified to contain only types that are subtypes of A

    N

    The minimum number of types (subtypes of A) that are needed to be present in L

    A

    The supertype of all types present in L

    Annotations

    @implicitNotFound( ... )

11.  trait BListProtocol extends AnyRef
12.  trait BListProtocolExtra extends AnyRef
13.  sealed trait BulkString extends RESP

    RESP Bulk Strings

    RESP Bulk Strings

    There can be 2 cases:

    • null bulk strings, where the length is -1 and no actual underlying string is present
    • actual (non-null) bulk strings, where the length is >= 0

    Non-null BulkStrings can be constructed using the RESPBuilders#bulk method

    Example:

    1. import laserdisc.protocol.RESP._
       
       val nonNullBulkString: NonNullBulkString = bulk("some string")
       val nullBulkString: NullBulkString       = nullBulk

    Note

    A forwarder for null BulkStrings is present too and represented using the final vals RESPBuilders.nullBulk

    See also

    Show

14.  final type ConnectionName = Refined[String, And[NonEmpty, Forall[Not[Whitespace]]]]
15.  trait ConnectionProtocol extends AnyRef
16.  final type DbIndex = Refined[Int, Closed[_0, shapeless.Nat._15]]
17.  final type Double = Refined[scala.Double, NonNaN]
18.  sealed abstract class Error extends LaserDiscRuntimeError with RESP

    RESP Errors

    RESP Errors

    RESP Errors are also scala.RuntimeExceptions, although where possible they will not contain stacktrace data

    These can be constructed by using the RESPBuilders#err method

    Example:

    1. import laserdisc.protocol.RESP._
       
       val error: Error = err("some error message")

19.  final type GlobPattern = Refined[String, MatchesRegex[String("(\\[?[\\w\\*\\?]+\\]?)+")]]
20.  trait HashProtocol extends AnyRef
21.  trait HashProtocolExtra extends AnyRef
22.  trait HyperLogLogProtocol extends AnyRef
23.  trait HyperLogLogProtocolExtra extends AnyRef
24.  final type Index = Refined[Long, True]
25.  sealed abstract class Integer extends RESP

    RESP Integers

    RESP Integers

    These can be constructed by using the RESPBuilders#int method

    Example:

    1. import laserdisc.protocol.RESP._
       
       val integer: Integer = int(42)

    Note

    Sometimes the values 0 and 1 are used to represent boolean values. In this case 0 corresponds to False while 1 to True, respectively. These are represented using the final vals RESPBuilders.falseI and RESPBuilders.trueI, respectively

26.  trait KeyProtocol extends AnyRef
27.  trait KeyProtocolExtra extends AnyRef
28.  final case class KeyValue[A, B](key: A, value: B) extends Product2[A, B] with Product with Serializable
29.  trait ListProtocol extends AnyRef
30.  trait ListProtocolExtra extends AnyRef
31.  trait LowPriorityRESPParamWrite extends LowestPriorityRESPParamWrite
32.  trait LowPriorityReadInstances extends AnyRef
33.  trait LowPriorityShowInstances extends AnyRef
34.  sealed trait LowestPriorityRESPParamWrite extends AnyRef
35.  final case class NaN() extends Product with Serializable
36.  sealed trait NilArray extends Array
37.  final type NonEmptyString = Refined[String, NonEmpty]
38.  final type NonNegInt = Refined[Int, Greater[Int(-1)]]
39.  final type NonNegLong = Refined[Long, Greater[Long(-1L)]]
40.  sealed abstract class NonNilArray extends Array

    This is the special case of a non-nil RESP Array

    This is the special case of a non-nil RESP Array

    These can be constructed by using the RESPBuilders#arr(xs: Seq[RESP]) method

    or

    by resorting to the overloaded RESPBuilders#arr(one: RESP, rest: RESP*) method which expects one parameter to be supplied followed by a (possibly empty) sequence of RESPs (vararg).

41.  sealed abstract class NonNullBulkString extends BulkString

    This is the special case of a non-null RESP BulkString

    This is the special case of a non-null RESP BulkString

    These can be constructed by using the RESPBuilders#bulk method

42.  final type NonZeroDouble = Refined[scala.Double, And[NonNaN, NonZero]]
43.  final type NonZeroInt = Refined[Int, NonZero]
44.  final type NonZeroLong = Refined[Long, NonZero]
45.  sealed trait NullBulkString extends BulkString
46.  sealed trait OK extends AnyRef
47.  final type PosInt = Refined[Int, Greater[Int(0)]]
48.  final type PosLong = Refined[Long, Greater[Long(0L)]]
49.  sealed trait Protocol extends Request with Response
50.  sealed trait ProtocolCodec[A] extends Any
51.  trait PublishProtocol extends AnyRef
52.  sealed trait RESP extends Serializable

    Redis Protocol Specification

    Redis Protocol Specification

    This sealed trait represents the entire Redis Serialization Protocol algebra

    Concrete instances of this trait must be created using this trait's companion object's methods, were scodec.Codecs for each are also defined

    See also

    RESPCodecs

    RESPBuilders

53.  trait RESPBuilders extends AnyRef
54.  trait RESPCodecs extends AnyRef
55.  trait RESPParamWrite[A] extends AnyRef

    Annotations

    @implicitNotFound( ... ) @inductive()

56.  trait RESPRead[A] extends AnyRef

    Annotations

    @implicitNotFound( ... )

57.  final type RangeOffset = Refined[Int, Closed[_0, Int(536870911)]]
58.  trait Read[A, B] extends AnyRef

    Annotations

    @implicitNotFound( ... )

59.  sealed trait Request extends AnyRef
60.  sealed trait Response extends AnyRef
61.  final case class Scan[A](cursor: NonNegLong, values: Option[Seq[A]]) extends Product with Serializable
62.  final case class ScanKV(cursor: NonNegLong, maybeValues: Option[Seq[KeyValue[NonEmptyString, String]]]) extends Product with Serializable
63.  trait ServerProtocol extends AnyRef
64.  trait SetProtocol extends AnyRef
65.  trait SetProtocolExtra extends AnyRef
66.  trait Show[A] extends AnyRef

    Annotations

    @implicitNotFound( ... )

67.  sealed abstract class SimpleString extends RESP

    RESP Simple Strings

    RESP Simple Strings

    These can be constructed by using the RESPBuilders#str method

    Example:

    1. import laserdisc.protocol.RESP._
       
       val simpleString: SimpleString = str("some string")

    Note

    Sometimes the value "OK" is used to represent a successful acknowledgement/processing of a command. This is represented using the final val RESPBuilders.ok

68.  trait SortedSetProtocol extends AnyRef
69.  trait SortedSetProtocolExtra extends AnyRef
70.  final type StringLength = Refined[Long, Closed[_0, Long(4294967295L)]]
71.  trait StringProtocol extends AnyRef
72.  trait StringProtocolExtra extends AnyRef
73.  final case class Time(timestamp: NonNegLong, elapsedMicroseconds: NonNegLong) extends Product with Serializable
74.  sealed trait UnzipAndInsert[L <: HList, A] extends DepFn2[L, A] with Serializable

    This type-class serves two purposes:

    This type-class serves two purposes:

    • as a witness of the ability for a HList to be unzipped (iff made of Tuple2/pairs)
    • as a higher-ranked function that allows the caller to invoke it (using an instance of the HList and an instance of some type A that needs to be inserted) to unzip the HList into exactly two HList and then concatenate these two after having inserted between them that instance of A.

    L

    The HList that will be unzipped iff it contains Tuple2

    A

    The type we want to insert before concatenation

    Annotations

    @implicitNotFound( ... )