protocol

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( ... )