Trait

laserdisc.protocol

AllHashP

Related Doc: package protocol

Permalink

trait AllHashP extends HashP with HashPExtra

Source
HashP.scala
Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AllHashP
  2. HashPExtra
  3. HashP
  4. AnyRef
  5. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to any2stringadd[AllHashP] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (AllHashP, B)

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to ArrowAssoc[AllHashP] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  5. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  6. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  7. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  8. def ensuring(cond: (AllHashP) ⇒ Boolean, msg: ⇒ Any): AllHashP

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to Ensuring[AllHashP] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  9. def ensuring(cond: (AllHashP) ⇒ Boolean): AllHashP

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to Ensuring[AllHashP] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  10. def ensuring(cond: Boolean, msg: ⇒ Any): AllHashP

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to Ensuring[AllHashP] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  11. def ensuring(cond: Boolean): AllHashP

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to Ensuring[AllHashP] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  12. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  14. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. def formatted(fmtstr: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to StringFormat[AllHashP] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  16. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  17. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  18. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key, field19: Key, field20: Key, field21: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  19. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key, field19: Key, field20: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  20. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key, field19: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  21. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  22. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  23. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  24. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  25. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  26. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  27. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  28. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  29. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  30. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  31. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  32. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  33. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  34. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  35. final def hdel(key: Key, field1: Key, field2: Key, field3: Key, field4: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  36. final def hdel(key: Key, field1: Key, field2: Key, field3: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  37. final def hdel(key: Key, field1: Key, field2: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  38. final def hdel(key: Key, field1: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashPExtra
  39. final def hdel(key: Key, fields: OneOrMoreKeys): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashP
  40. final def hexists(key: Key, field: Key): Aux[Boolean]

    Permalink
    Definition Classes
    HashP
  41. final def hget[A](key: Key, field: Key)(implicit ev: Read.==>[NonNullBulkString, A]): Aux[Option[A]]

    Permalink
    Definition Classes
    HashP
  42. final def hgetall[A](key: Key)(implicit ev: Read.==>[NonNilArray, A]): Aux[A]

    Permalink
    Definition Classes
    HashP
  43. final def hincrby(key: Key, field: Key, increment: NonZeroLong): Aux[Long]

    Permalink
    Definition Classes
    HashP
  44. final def hincrbyfloat(key: Key, field: Key, increment: NonZeroDouble): Aux[Double]

    Permalink
    Definition Classes
    HashP
  45. final def hkeys(key: Key): Aux[Seq[Key]]

    Permalink
    Definition Classes
    HashP
  46. final def hlen(key: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashP
  47. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key, field19: Key, field20: Key, field21: Key)(implicit ev20: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, ::[A19, ::[A20, ::[A21, HNil]]]]]]]]]]]]]]]]]]]]]], ev21: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, ::[A19, ::[A20, ::[A21, HNil]]]]]]]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]

    Permalink
    Definition Classes
    HashPExtra
  48. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key, field19: Key, field20: Key)(implicit ev19: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, ::[A19, ::[A20, HNil]]]]]]]]]]]]]]]]]]]]], ev20: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, ::[A19, ::[A20, HNil]]]]]]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]

    Permalink
    Definition Classes
    HashPExtra
  49. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key, field19: Key)(implicit ev18: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, ::[A19, HNil]]]]]]]]]]]]]]]]]]]], ev19: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, ::[A19, HNil]]]]]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]

    Permalink
    Definition Classes
    HashPExtra
  50. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key, field18: Key)(implicit ev17: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, HNil]]]]]]]]]]]]]]]]]]], ev18: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, ::[A18, HNil]]]]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]

    Permalink
    Definition Classes
    HashPExtra
  51. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key, field17: Key)(implicit ev16: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, HNil]]]]]]]]]]]]]]]]]], ev17: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, ::[A17, HNil]]]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]

    Permalink
    Definition Classes
    HashPExtra
  52. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key, field16: Key)(implicit ev15: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, HNil]]]]]]]]]]]]]]]]], ev16: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, ::[A16, HNil]]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]

    Permalink
    Definition Classes
    HashPExtra
  53. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key, field15: Key)(implicit ev14: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, HNil]]]]]]]]]]]]]]]], ev15: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, ::[A15, HNil]]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]

    Permalink
    Definition Classes
    HashPExtra
  54. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key, field14: Key)(implicit ev13: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, HNil]]]]]]]]]]]]]]], ev14: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, ::[A14, HNil]]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]

    Permalink
    Definition Classes
    HashPExtra
  55. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key, field13: Key)(implicit ev12: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, HNil]]]]]]]]]]]]]], ev13: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, ::[A13, HNil]]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]

    Permalink
    Definition Classes
    HashPExtra
  56. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key, field12: Key)(implicit ev11: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, HNil]]]]]]]]]]]]], ev12: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, ::[A12, HNil]]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]

    Permalink
    Definition Classes
    HashPExtra
  57. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key, field11: Key)(implicit ev10: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, HNil]]]]]]]]]]]], ev11: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, ::[A11, HNil]]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]

    Permalink
    Definition Classes
    HashPExtra
  58. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key, field10: Key)(implicit ev9: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, HNil]]]]]]]]]]], ev10: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, ::[A10, HNil]]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]

    Permalink
    Definition Classes
    HashPExtra
  59. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8, A9](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key, field9: Key)(implicit ev8: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, HNil]]]]]]]]]], ev9: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, ::[A9, HNil]]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8, A9)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8, A9)]

    Permalink
    Definition Classes
    HashPExtra
  60. final def hmget[A1, A2, A3, A4, A5, A6, A7, A8](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key, field8: Key)(implicit ev7: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, HNil]]]]]]]]], ev8: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, ::[A8, HNil]]]]]]]], (A1, A2, A3, A4, A5, A6, A7, A8)]): Aux[(A1, A2, A3, A4, A5, A6, A7, A8)]

    Permalink
    Definition Classes
    HashPExtra
  61. final def hmget[A1, A2, A3, A4, A5, A6, A7](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key, field7: Key)(implicit ev6: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, HNil]]]]]]]], ev7: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, ::[A7, HNil]]]]]]], (A1, A2, A3, A4, A5, A6, A7)]): Aux[(A1, A2, A3, A4, A5, A6, A7)]

    Permalink
    Definition Classes
    HashPExtra
  62. final def hmget[A1, A2, A3, A4, A5, A6](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key, field6: Key)(implicit ev5: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, HNil]]]]]]], ev6: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, ::[A6, HNil]]]]]], (A1, A2, A3, A4, A5, A6)]): Aux[(A1, A2, A3, A4, A5, A6)]

    Permalink
    Definition Classes
    HashPExtra
  63. final def hmget[A1, A2, A3, A4, A5](key: Key, field1: Key, field2: Key, field3: Key, field4: Key, field5: Key)(implicit ev4: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, ::[A5, HNil]]]]]], ev5: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, ::[A5, HNil]]]]], (A1, A2, A3, A4, A5)]): Aux[(A1, A2, A3, A4, A5)]

    Permalink
    Definition Classes
    HashPExtra
  64. final def hmget[A1, A2, A3, A4](key: Key, field1: Key, field2: Key, field3: Key, field4: Key)(implicit ev3: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, ::[A4, HNil]]]]], ev4: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, ::[A4, HNil]]]], (A1, A2, A3, A4)]): Aux[(A1, A2, A3, A4)]

    Permalink
    Definition Classes
    HashPExtra
  65. final def hmget[A1, A2, A3](key: Key, field1: Key, field2: Key, field3: Key)(implicit ev2: Read.==>[NonNilArray, ::[A1, ::[A2, ::[A3, HNil]]]], ev3: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, ::[A3, HNil]]], (A1, A2, A3)]): Aux[(A1, A2, A3)]

    Permalink
    Definition Classes
    HashPExtra
  66. final def hmget[A1, A2](key: Key, field1: Key, field2: Key)(implicit ev1: Read.==>[NonNilArray, ::[A1, ::[A2, HNil]]], ev2: shapeless.ops.hlist.Tupler.Aux[::[A1, ::[A2, HNil]], (A1, A2)]): Aux[(A1, A2)]

    Permalink
    Definition Classes
    HashPExtra
  67. final def hmget[A1](key: Key, field1: Key)(implicit ev: Read.==>[NonNilArray, ::[A1, HNil]]): Aux[A1]

    Permalink
    Definition Classes
    HashPExtra
  68. final def hmget[L <: HList](key: Key, fields: OneOrMoreKeys)(implicit ev: Read.==>[NonNilArray, L]): Aux[L]

    Permalink
    Definition Classes
    HashP
  69. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15, A16 <: XString, B16, A17 <: XString, B17, A18 <: XString, B18, A19 <: XString, B19, A20 <: XString, B20, A21 <: XString, B21](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15, field16: SingletonKey[A16], value16: B16, field17: SingletonKey[A17], value17: B17, field18: SingletonKey[A18], value18: B18, field19: SingletonKey[A19], value19: B19, field20: SingletonKey[A20], value20: B20, field21: SingletonKey[A21], value21: B21)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15], arg15: Show[B16], arg16: Show[B17], arg17: Show[B18], arg18: Show[B19], arg19: Show[B20], arg20: Show[B21]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  70. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15, A16 <: XString, B16, A17 <: XString, B17, A18 <: XString, B18, A19 <: XString, B19, A20 <: XString, B20](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15, field16: SingletonKey[A16], value16: B16, field17: SingletonKey[A17], value17: B17, field18: SingletonKey[A18], value18: B18, field19: SingletonKey[A19], value19: B19, field20: SingletonKey[A20], value20: B20)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15], arg15: Show[B16], arg16: Show[B17], arg17: Show[B18], arg18: Show[B19], arg19: Show[B20]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  71. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15, A16 <: XString, B16, A17 <: XString, B17, A18 <: XString, B18, A19 <: XString, B19](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15, field16: SingletonKey[A16], value16: B16, field17: SingletonKey[A17], value17: B17, field18: SingletonKey[A18], value18: B18, field19: SingletonKey[A19], value19: B19)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15], arg15: Show[B16], arg16: Show[B17], arg17: Show[B18], arg18: Show[B19]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  72. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15, A16 <: XString, B16, A17 <: XString, B17, A18 <: XString, B18](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15, field16: SingletonKey[A16], value16: B16, field17: SingletonKey[A17], value17: B17, field18: SingletonKey[A18], value18: B18)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15], arg15: Show[B16], arg16: Show[B17], arg17: Show[B18]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  73. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15, A16 <: XString, B16, A17 <: XString, B17](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15, field16: SingletonKey[A16], value16: B16, field17: SingletonKey[A17], value17: B17)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15], arg15: Show[B16], arg16: Show[B17]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  74. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15, A16 <: XString, B16](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15, field16: SingletonKey[A16], value16: B16)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15], arg15: Show[B16]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  75. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14, A15 <: XString, B15](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14, field15: SingletonKey[A15], value15: B15)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14], arg14: Show[B15]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  76. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13, A14 <: XString, B14](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13, field14: SingletonKey[A14], value14: B14)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13], arg13: Show[B14]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  77. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12, A13 <: XString, B13](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12, field13: SingletonKey[A13], value13: B13)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12], arg12: Show[B13]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  78. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11, A12 <: XString, B12](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11, field12: SingletonKey[A12], value12: B12)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11], arg11: Show[B12]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  79. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10, A11 <: XString, B11](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10, field11: SingletonKey[A11], value11: B11)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10], arg10: Show[B11]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  80. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9, A10 <: XString, B10](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9, field10: SingletonKey[A10], value10: B10)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9], arg9: Show[B10]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  81. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8, A9 <: XString, B9](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8, field9: SingletonKey[A9], value9: B9)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8], arg8: Show[B9]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  82. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7, A8 <: XString, B8](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7, field8: SingletonKey[A8], value8: B8)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7], arg7: Show[B8]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  83. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6, A7 <: XString, B7](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6, field7: SingletonKey[A7], value7: B7)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6], arg6: Show[B7]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  84. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5, A6 <: XString, B6](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5, field6: SingletonKey[A6], value6: B6)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5], arg5: Show[B6]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  85. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4, A5 <: XString, B5](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4, field5: SingletonKey[A5], value5: B5)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4], arg4: Show[B5]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  86. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3, A4 <: XString, B4](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3, field4: SingletonKey[A4], value4: B4)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3], arg3: Show[B4]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  87. final def hmset[A1 <: XString, B1, A2 <: XString, B2, A3 <: XString, B3](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2, field3: SingletonKey[A3], value3: B3)(implicit arg0: Show[B1], arg1: Show[B2], arg2: Show[B3]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  88. final def hmset[A1 <: XString, B1, A2 <: XString, B2](key: Key, field1: SingletonKey[A1], value1: B1, field2: SingletonKey[A2], value2: B2)(implicit arg0: Show[B1], arg1: Show[B2]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  89. final def hmset[A1 <: XString, B1](key: Key, field1: SingletonKey[A1], value1: B1)(implicit arg0: Show[B1]): Aux["OK"]

    Permalink
    Definition Classes
    HashPExtra
  90. final def hmset[P <: Product, L <: HList, N <: Nat](key: Key, product: P)(implicit gen: Aux[P, L], ev0: Aux[L, N], ev1: >=[N, shapeless.Nat._1], ev2: LUBConstraint[L, FieldType[_, _]], ev3: RESPParamWrite[L]): Aux["OK"]

    Permalink
    Definition Classes
    HashP
  91. final def hmset[L <: HList, N <: Nat](key: Key, l: L)(implicit arg0: RESPParamWrite[L], ev0: Aux[L, N], ev1: >=[N, shapeless.Nat._1], ev2: LUBConstraint[L, FieldType[_, _]]): Aux["OK"]

    Permalink
    Definition Classes
    HashP
  92. final def hscan(key: Key, cursor: NonNegLong, pattern: GlobPattern, count: PosInt): Aux[ScanKV]

    Permalink
    Definition Classes
    HashP
  93. final def hscan(key: Key, cursor: NonNegLong, count: PosInt): Aux[ScanKV]

    Permalink
    Definition Classes
    HashP
  94. final def hscan(key: Key, cursor: NonNegLong, pattern: GlobPattern): Aux[ScanKV]

    Permalink
    Definition Classes
    HashP
  95. final def hscan(key: Key, cursor: NonNegLong): Aux[ScanKV]

    Permalink
    Definition Classes
    HashP
  96. final def hset[A](key: Key, field: Key, value: A)(implicit arg0: Show[A]): Aux[Boolean]

    Permalink
    Definition Classes
    HashP
  97. final def hsetnx[A](key: Key, field: Key, value: A)(implicit arg0: Show[A]): Aux[Boolean]

    Permalink
    Definition Classes
    HashP
  98. final def hstrlen(key: Key, field: Key): Aux[NonNegInt]

    Permalink
    Definition Classes
    HashP
  99. final def hvals[L <: HList](key: Key)(implicit ev: Read.==>[NonNilArray, L]): Aux[L]

    Permalink
    Definition Classes
    HashP
  100. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  101. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  102. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  103. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  104. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  105. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  106. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  107. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  108. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  109. def [B](y: B): (AllHashP, B)

    Permalink
    Implicit information
    This member is added by an implicit conversion from AllHashP to ArrowAssoc[AllHashP] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Inherited from HashPExtra

Inherited from HashP

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from AllHashP to any2stringadd[AllHashP]

Inherited by implicit conversion StringFormat from AllHashP to StringFormat[AllHashP]

Inherited by implicit conversion Ensuring from AllHashP to Ensuring[AllHashP]

Inherited by implicit conversion ArrowAssoc from AllHashP to ArrowAssoc[AllHashP]

Ungrouped