Type Members

1.  final case class Arr(elements: List[RESP]) extends GenArr with Product with Serializable

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

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

   These can be constructed either by the default case class' apply by resorting to the overloaded Arr#apply(one: RESP, rest: RESP*) method which expects one parameter to be supplied followed by a (possibly empty) sequence of RESPs (vararg).

   elements

   The wrapped array values, as a scala.List of RESP

2.  trait BListBaseP extends AnyRef
3.  trait BListExtP extends AnyRef
4.  trait BListP extends BListBaseP with BListExtP
5.  final case class Bulk(value: String) extends GenBulk with Product with Serializable

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

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

   These can be constructed by using the RESPBuilders#bulk method

   value

   The wrapped bulk string value

6.  trait ClusterP extends AnyRef
7.  trait ConnectionP extends AnyRef
8.  final case class Err(message: String) extends LaserDiscRuntimeError with RESP with Product with Serializable

   RESP Errors

   RESP Errors

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

   message

   The wrapped exception's message

   Example:

   1. val e: Err = Err("some error message")

9.  sealed trait GenArr 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

   Example:

   1. val arr: Arr                = Arr(List(Str("hello"), Str("world")))
      val guaranteedNonEmpty: Arr = Arr(Str("hello"), Str("world"))
      val empty: Arr              = Arr(List.empty)
      val nil: NilArr             = NilArr

   Note

   Arr#apply(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 GenBulk 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

    Example:

    1. val b: Bulk      = Bulk("some string")
       val nb: NullBulk = NullBulk

    See also

    Show

11.  trait GeoBaseP extends AnyRef
12.  trait GeoExtP extends AnyRef
13.  trait GeoP extends GeoBaseP with GeoExtP
14.  trait HashBaseP extends AnyRef
15.  trait HashExtP extends AnyRef
16.  trait HashP extends HashBaseP with HashExtP
17.  trait HyperLogLogBaseP extends AnyRef
18.  trait HyperLogLogExtP extends AnyRef
19.  trait HyperLogLogP extends HyperLogLogBaseP with HyperLogLogExtP
20.  trait KeyBaseP extends AnyRef
21.  trait KeyExtP extends AnyRef
22.  trait KeyP extends KeyBaseP with KeyExtP
23.  final class LenientStringCodec extends Codec[String]
24.  trait ListBaseP extends AnyRef
25.  trait ListExtP extends AnyRef
26.  trait ListP extends ListBaseP with ListExtP
27.  final case class Num(value: Long) extends RESP with Product with Serializable

    RESP Integers

    RESP Integers

    value

    The wrapped long value

    Example:

    1. val n: Num = Num(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.

28.  sealed trait Protocol extends Request with Response
29.  sealed trait ProtocolCodec[A] extends Any
30.  trait PublishP extends AnyRef
31.  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

    RESPBuilders

    RESPCodecs

32.  sealed trait RESPCodecs extends BitVectorSyntax
33.  sealed trait RESPCoproduct extends AnyRef
34.  final case class RESPDecErr(message: String) extends LaserDiscRespProtocolDecodingError with Product with Serializable
35.  sealed trait RESPFunctions extends EitherSyntax
36.  trait RESPParamWrite[A] extends AnyRef

    Annotations

    @implicitNotFound("""Implicit not found RESPParamWrite[${A}].
    
    Normally you would not need to define one manually, as one will be derived for you automatically iff:
    - an instance of Show[${A}] is in scope
    - ${A} is a List whose LUB has a RESPParamWrite instance defined
    - ${A} is an HList whose elements all have a RESPParamWrite instance defined
    """)

37.  trait RESPRead[A] extends AnyRef

    Annotations

    @implicitNotFound("""Implicit not found RESPRead[${A}].
    
    You should not need to define one manually, as one will be derived for you automatically iff:
    - evidence of a Read instance from some sum/co-product to ${A} can be provided
    - this sum/co-product is a subset of the sum-co-product for RESP
    """)

38.  trait Read[A, B] extends AnyRef

    Annotations

    @implicitNotFound("""Implicit not found Read[${A}, ${B}].
    
    Try writing your own, for example:
    
    implicit final val myRead: Read[${A}, ${B}] = new Read[${A}, ${B}] {
    override final def read(a: ${A}): Option[${B}] = ???
    }
    
    Note 1: you can use the factory method Read.instance instead of creating it manually as shown above
    Note 2: make sure to inspect the combinators as you may be able to leverage some other Read instance
    """)

39.  trait ReadInstances0 extends ReadInstances1
40.  trait ReadInstances1 extends EitherSyntax with ReadInstances2
41.  sealed trait ReadInstances2 extends AnyRef
42.  sealed trait Request extends AnyRef
43.  sealed trait Response extends AnyRef
44.  trait ServerP extends AnyRef
45.  trait SetBaseP extends AnyRef
46.  trait SetExtP extends AnyRef
47.  trait SetP extends SetBaseP with SetExtP
48.  trait Show[A] extends AnyRef

    Annotations

    @implicitNotFound("""Implicit not found Show[${A}].
    
    Try writing your own, for example:
    
    implicit final val myShow: Show[${A}] = new Show[${A}] {
    override final def show(a: ${A}): String = ???
    }
    """)

49.  trait SortedSetBaseP extends AnyRef
50.  trait SortedSetExtP extends AnyRef
51.  trait SortedSetP extends SortedSetBaseP with SortedSetExtP
52.  final case class Str(value: String) extends RESP with Product with Serializable

    RESP Simple Strings

    RESP Simple Strings

    value

    The wrapped string value

    Example:

    1. val s: Str = Str("some string")

    Note

    Sometimes the value "OK" is used to represent a successful acknowledgement/processing of a command.

53.  trait StringBaseP extends AnyRef
54.  trait StringExtP extends AnyRef
55.  trait StringP extends StringBaseP with StringExtP
56.  trait TransactionP extends AnyRef