Skip to content
Permalink
Browse files

Replaced kind projector's ? with *. Added formatting alias (#135)

  • Loading branch information...
barambani authored and sirocchj committed Sep 7, 2019
1 parent 5c69098 commit bccc5a71145859d2f5621fef762d2885bbc66295
@@ -328,5 +328,6 @@ lazy val laserdisc = project
.aggregate(core.jvm, core.js, fs2, cli, circe.jvm, circe.js)
.settings(publishSettings)
.settings(
publishArtifact := false
publishArtifact := false,
addCommandAlias("fmt", ";scalafmt;test:scalafmt;scalafmtSbt")
)
@@ -205,17 +205,17 @@ package object laserdisc {
}

private[laserdisc] implicit final class WidenOps1[F[_], A](private val fa: F[A]) extends AnyVal {
def widen[AA: <:<[A, ?]: =:!=[A, ?]]: F[AA] = fa.asInstanceOf[F[AA]]
def widen[AA: <:<[A, *]: =:!=[A, *]]: F[AA] = fa.asInstanceOf[F[AA]]
}

private[laserdisc] implicit final class WidenOps2[F[_, _], A, B](private val fab: F[A, B]) extends AnyVal {
def widenLeft[AA: <:<[A, ?]: =:!=[A, ?]]: F[AA, B] = fab.asInstanceOf[F[AA, B]]
def widenRight[BB: <:<[B, ?]: =:!=[B, ?]]: F[A, BB] = fab.asInstanceOf[F[A, BB]]
def widenLeft[AA: <:<[A, *]: =:!=[A, *]]: F[AA, B] = fab.asInstanceOf[F[AA, B]]
def widenRight[BB: <:<[B, *]: =:!=[B, *]]: F[A, BB] = fab.asInstanceOf[F[A, BB]]
def coerceLeft[AA, FF[_, _]](implicit ev: F[AA, B] <:< FF[AA, B]): FF[AA, B] = fab.asInstanceOf[FF[AA, B]]
def coerceRight[FF[_, _], BB](implicit ev: F[A, BB] <:< FF[A, BB]): FF[A, BB] = fab.asInstanceOf[FF[A, BB]]
}

private[laserdisc] implicit final class WidenOps3[F[_[_], _], G[_], A](private val fga: F[G, A]) extends AnyVal {
def widenRight[AA: <:<[A, ?]: =:!=[A, ?]]: F[G, AA] = fga.asInstanceOf[F[G, AA]]
def widenRight[AA: <:<[A, *]: =:!=[A, *]]: F[G, AA] = fga.asInstanceOf[F[G, AA]]
}
}
@@ -4,15 +4,15 @@ package protocol
trait BListBaseP {
import shapeless._

final def blpop[A: Bulk ==> ?](keys: OneOrMoreKeys, seconds: NonNegInt): Protocol.Aux[Option[KV[A]]] =
final def blpop[A: Bulk ==> *](keys: OneOrMoreKeys, seconds: NonNegInt): Protocol.Aux[Option[KV[A]]] =
Protocol("BLPOP", keys.value :: seconds :: HNil).opt[GenArr].as[KV[A]]

final def brpop[A: Bulk ==> ?](keys: OneOrMoreKeys, seconds: NonNegInt): Protocol.Aux[Option[KV[A]]] =
final def brpop[A: Bulk ==> *](keys: OneOrMoreKeys, seconds: NonNegInt): Protocol.Aux[Option[KV[A]]] =
Protocol("BRPOP", keys.value :: seconds :: HNil).opt[GenArr].as[KV[A]]

final def brpoplpush[A: Bulk ==> ?](source: Key, destination: Key): Protocol.Aux[Option[A]] =
final def brpoplpush[A: Bulk ==> *](source: Key, destination: Key): Protocol.Aux[Option[A]] =
Protocol("BRPOPLPUSH", source :: destination :: 0 :: HNil).opt[GenBulk].as[A]
final def brpoplpush[A: Bulk ==> ?](source: Key, destination: Key, timeout: PosInt): Protocol.Aux[Option[A]] =
final def brpoplpush[A: Bulk ==> *](source: Key, destination: Key, timeout: PosInt): Protocol.Aux[Option[A]] =
Protocol("BRPOPLPUSH", source :: destination :: timeout :: HNil).opt[GenBulk].as[A]
}

@@ -6,10 +6,10 @@ trait ConnectionP {

final def auth(password: Key): Protocol.Aux[OK] = Protocol("AUTH", password).as[Str, OK]

final def echo[A: Show: Bulk ==> ?](message: A): Protocol.Aux[A] = Protocol("ECHO", message).as[Bulk, A]
final def echo[A: Show: Bulk ==> *](message: A): Protocol.Aux[A] = Protocol("ECHO", message).as[Bulk, A]

final val ping: Protocol.Aux[PONG] = Protocol("PING", Nil).as[Str, PONG]
final def ping[A: Show: Bulk ==> ?](message: A): Protocol.Aux[A] = Protocol("PING", message).as[Bulk, A]
final def ping[A: Show: Bulk ==> *](message: A): Protocol.Aux[A] = Protocol("PING", message).as[Bulk, A]

final val quit: Protocol.Aux[OK] = Protocol("QUIT", Nil).as[Str, OK]

@@ -12,10 +12,10 @@ trait HashBaseP {

final def hexists(key: Key, field: Key): Protocol.Aux[Boolean] = Protocol("HEXISTS", key :: field :: Nil).as[Num, Boolean]

final def hget[A: Bulk ==> ?](key: Key, field: Key): Protocol.Aux[Option[A]] =
final def hget[A: Bulk ==> *](key: Key, field: Key): Protocol.Aux[Option[A]] =
Protocol("HGET", key :: field :: Nil).opt[GenBulk].as[A]

final def hgetall[A: Arr ==> ?](key: Key): Protocol.Aux[A] = Protocol("HGETALL", key).as[Arr, A]
final def hgetall[A: Arr ==> *](key: Key): Protocol.Aux[A] = Protocol("HGETALL", key).as[Arr, A]

final def hincrby(key: Key, field: Key, increment: NonZeroLong): Protocol.Aux[Long] =
Protocol("HINCRBY", key :: field :: increment :: HNil).as[Num, Long]
@@ -26,10 +26,10 @@ trait HashBaseP {

final def hlen(key: Key): Protocol.Aux[NonNegInt] = Protocol("HLEN", key).as[Num, NonNegInt]

final def hmget[L <: HList: Arr ==> ?](key: Key, fields: OneOrMoreKeys): Protocol.Aux[L] =
final def hmget[L <: HList: Arr ==> *](key: Key, fields: OneOrMoreKeys): Protocol.Aux[L] =
Protocol("HMGET", key :: fields.value).as[Arr, L]

final def hmset[L <: HList: RESPParamWrite: LUBConstraint[?, (Key, _)], N <: Nat](key: Key, l: L)(
final def hmset[L <: HList: RESPParamWrite: LUBConstraint[*, (Key, _)], N <: Nat](key: Key, l: L)(
implicit ev0: Length.Aux[L, N],
ev1: N >= _1
): Protocol.Aux[OK] = Protocol("HMSET", key :: l).as[Str, OK]
@@ -57,7 +57,7 @@ trait HashBaseP {

final def hstrlen(key: Key, field: Key): Protocol.Aux[NonNegInt] = Protocol("HSTRLEN", key :: field :: Nil).as[Num, NonNegInt]

final def hvals[L <: HList: Arr ==> ?](key: Key): Protocol.Aux[L] = Protocol("HVALS", key).as[Arr, L]
final def hvals[L <: HList: Arr ==> *](key: Key): Protocol.Aux[L] = Protocol("HVALS", key).as[Arr, L]
}

trait HashP extends HashBaseP with HashExtP
@@ -200,12 +200,12 @@ trait KeyBaseP {
Protocol("SCAN", cursor :: "MATCH" :: pattern :: "COUNT" :: count :: HNil).as[Arr, Scan[Key]]

//FIXME sort has many more combinations
final def sort[A: Bulk ==> ?](key: Key): Protocol.Aux[Seq[A]] = Protocol("SORT", key).as[Arr, Seq[A]]
final def sort[A: Bulk ==> ?](key: Key, pattern: GlobPattern): Protocol.Aux[Seq[A]] =
final def sort[A: Bulk ==> *](key: Key): Protocol.Aux[Seq[A]] = Protocol("SORT", key).as[Arr, Seq[A]]
final def sort[A: Bulk ==> *](key: Key, pattern: GlobPattern): Protocol.Aux[Seq[A]] =
Protocol("SORT", key :: "BY" :: pattern :: HNil).as[Arr, Seq[A]]
final def sort[A: Bulk ==> ?](key: Key, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
final def sort[A: Bulk ==> *](key: Key, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
Protocol("SORT", key :: "LIMIT" :: offset :: count :: HNil).as[Arr, Seq[A]]
final def sort[A: Bulk ==> ?](key: Key, direction: Direction): Protocol.Aux[Seq[A]] =
final def sort[A: Bulk ==> *](key: Key, direction: Direction): Protocol.Aux[Seq[A]] =
Protocol("SORT", key :: direction :: HNil).as[Arr, Seq[A]]
final def sort(key: Key, destination: Key): Protocol.Aux[NonNegInt] =
Protocol("SORT", key.value :: "STORE" :: destination.value :: Nil).as[Num, NonNegInt]
@@ -28,22 +28,22 @@ trait ListBaseP {
private[this] final val minusOneIsNone = RESPRead.instance(Read.numMinusOneIsNone[PosInt])
private[this] final val zeroIsNone = RESPRead.instance(Read.numZeroIsNone[PosInt])

final def lindex[A: Bulk ==> ?](key: Key, index: Index): Protocol.Aux[Option[A]] =
final def lindex[A: Bulk ==> *](key: Key, index: Index): Protocol.Aux[Option[A]] =
Protocol("LINDEX", key :: index :: HNil).opt[GenBulk].as[A]

final def linsert[A: Show](key: Key, position: ListPosition, pivot: A, value: A): Protocol.Aux[Option[PosInt]] =
Protocol("LINSERT", key :: position :: pivot :: value :: HNil).using(minusOneIsNone)

final def llen(key: Key): Protocol.Aux[NonNegInt] = Protocol("LLEN", key).as[Num, NonNegInt]

final def lpop[A: Bulk ==> ?](key: Key): Protocol.Aux[Option[A]] = Protocol("LPOP", key).opt[GenBulk].as[A]
final def lpop[A: Bulk ==> *](key: Key): Protocol.Aux[Option[A]] = Protocol("LPOP", key).opt[GenBulk].as[A]

final def lpush[A: Show](key: Key, values: OneOrMore[A]): Protocol.Aux[PosInt] =
Protocol("LPUSH", key :: values.value :: HNil).as[Num, PosInt]

final def lpushx[A: Show](key: Key, value: A): Protocol.Aux[Option[PosInt]] = Protocol("LPUSHX", key :: value :: HNil).using(zeroIsNone)

final def lrange[A: Bulk ==> ?](key: Key, start: Index, end: Index): Protocol.Aux[Seq[A]] =
final def lrange[A: Bulk ==> *](key: Key, start: Index, end: Index): Protocol.Aux[Seq[A]] =
Protocol("LRANGE", key :: start :: end :: HNil).as[Arr, Seq[A]]

final def lrem[A: Show](key: Key, count: Index, value: A): Protocol.Aux[NonNegInt] =
@@ -53,9 +53,9 @@ trait ListBaseP {

final def ltrim(key: Key, start: Index, stop: Index): Protocol.Aux[OK] = Protocol("LTRIM", key :: start :: stop :: HNil).as[Str, OK]

final def rpop[A: Bulk ==> ?](key: Key): Protocol.Aux[Option[A]] = Protocol("RPOP", key).opt[GenBulk].as[A]
final def rpop[A: Bulk ==> *](key: Key): Protocol.Aux[Option[A]] = Protocol("RPOP", key).opt[GenBulk].as[A]

final def rpoplpush[A: Bulk ==> ?](source: Key, destination: Key): Protocol.Aux[Option[A]] =
final def rpoplpush[A: Bulk ==> *](source: Key, destination: Key): Protocol.Aux[Option[A]] =
Protocol("RPOPLPUSH", source :: destination :: Nil).opt[GenBulk].as[A]

final def rpush[A: Show](key: Key, values: OneOrMore[A]): Protocol.Aux[PosInt] =
@@ -51,10 +51,10 @@ object Read extends ReadInstances0 {
case Inl(_) => None
}

final def numMinusOneIsNone[A: Read[Num, ?]]: Read[Num :+: CNil, Option[A]] =
final def numMinusOneIsNone[A: Read[Num, *]]: Read[Num :+: CNil, Option[A]] =
lift2OptionWhen(_.value == -1L)

final def numZeroIsNone[A: Read[Num, ?]]: Read[Num :+: CNil, Option[A]] =
final def numZeroIsNone[A: Read[Num, *]]: Read[Num :+: CNil, Option[A]] =
lift2OptionWhen(_.value == 0L)
}

@@ -209,7 +209,7 @@ trait ReadInstances1 extends ReadInstances2 {
case _ => None
}

implicit final def arr2HCons[H: <:!<[?, FieldType[_, _]], T <: HList](
implicit final def arr2HCons[H: <:!<[*, FieldType[_, _]], T <: HList](
implicit RH: Read[Bulk, H],
RT: Read[Arr, T]
): Read[Arr, H :: T] = Read.instance {
@@ -228,7 +228,7 @@ sealed trait ReadInstances2 {
case Inl(R(b)) => Some(b)
case Inr(_) => None
}
implicit final def liftSimpleToSum[A: <:!<[?, Coproduct], B](implicit R: Read[A, B]): Read[A :+: CNil, B] = Read.instancePF {
implicit final def liftSimpleToSum[A: <:!<[*, Coproduct], B](implicit R: Read[A, B]): Read[A :+: CNil, B] = Read.instancePF {
case Inl(R(b)) => b
}
}
@@ -23,17 +23,17 @@ trait SetBaseP {

final def sismember[A: Show](key: Key, member: A): Protocol.Aux[Boolean] = Protocol("SISMEMBER", key :: member :: HNil).as[Num, Boolean]

final def smembers[A: Bulk ==> ?](key: Key): Protocol.Aux[Seq[A]] = Protocol("SMEMBERS", key).as[Arr, Seq[A]]
final def smembers[A: Bulk ==> *](key: Key): Protocol.Aux[Seq[A]] = Protocol("SMEMBERS", key).as[Arr, Seq[A]]

final def smove[A: Show](source: Key, destination: Key, member: A): Protocol.Aux[Boolean] =
Protocol("SMOVE", source :: destination :: member :: HNil).as[Num, Boolean]

final def spop[A: Bulk ==> ?](key: Key): Protocol.Aux[Option[A]] = Protocol("SPOP", key).opt[GenBulk].as[A]
final def spop[A: Bulk ==> ?](key: Key, count: PosInt): Protocol.Aux[Seq[A]] = Protocol("SPOP", key :: count :: HNil).as[Arr, Seq[A]]
final def spop[A: Bulk ==> *](key: Key): Protocol.Aux[Option[A]] = Protocol("SPOP", key).opt[GenBulk].as[A]
final def spop[A: Bulk ==> *](key: Key, count: PosInt): Protocol.Aux[Seq[A]] = Protocol("SPOP", key :: count :: HNil).as[Arr, Seq[A]]

final def srandmember[A: Bulk ==> ?](key: Key): Protocol.Aux[Option[A]] =
final def srandmember[A: Bulk ==> *](key: Key): Protocol.Aux[Option[A]] =
Protocol("SRANDMEMBER", key).opt[GenBulk].as[A]
final def srandmembers[A: Bulk ==> ?](key: Key, count: NonZeroInt): Protocol.Aux[Seq[A]] =
final def srandmembers[A: Bulk ==> *](key: Key, count: NonZeroInt): Protocol.Aux[Seq[A]] =
Protocol("SRANDMEMBER", key :: count :: HNil).as[Arr, Seq[A]]

final def srem[A: Show](key: Key, members: OneOrMore[A]): Protocol.Aux[NonNegInt] =
@@ -175,23 +175,23 @@ trait SortedSetBaseP {
final def zlexcount(key: Key, range: LexRange): Protocol.Aux[NonNegInt] =
Protocol("ZLEXCOUNT", key :: range.min :: range.max :: HNil).as[Num, NonNegInt]

final def zrange[A: Bulk ==> ?](key: Key, start: Index, stop: Index): Protocol.Aux[Seq[A]] =
final def zrange[A: Bulk ==> *](key: Key, start: Index, stop: Index): Protocol.Aux[Seq[A]] =
Protocol("ZRANGE", key :: start :: stop :: HNil).as[Arr, Seq[A]]

final def zrangebylex[A: Bulk ==> ?](key: Key, range: LexRange): Protocol.Aux[Seq[A]] =
final def zrangebylex[A: Bulk ==> *](key: Key, range: LexRange): Protocol.Aux[Seq[A]] =
Protocol("ZRANGEBYLEX", key :: range.min :: range.max :: HNil).as[Arr, Seq[A]]

final def zrangebylex[A: Bulk ==> ?](key: Key, range: LexRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
final def zrangebylex[A: Bulk ==> *](key: Key, range: LexRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
Protocol("ZRANGEBYLEX", key :: range.min :: range.max :: "LIMIT" :: offset :: count :: HNil).as[Arr, Seq[A]]

final def zrangebyscore[A: Bulk ==> ?](key: Key, range: ScoreRange): Protocol.Aux[Seq[A]] =
final def zrangebyscore[A: Bulk ==> *](key: Key, range: ScoreRange): Protocol.Aux[Seq[A]] =
Protocol("ZRANGEBYSCORE", key :: range.min :: range.max :: HNil).as[Arr, Seq[A]]
final def zrangebyscore[A: Bulk ==> ?](key: Key, range: ScoreRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
final def zrangebyscore[A: Bulk ==> *](key: Key, range: ScoreRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
Protocol("ZRANGEBYSCORE", key :: range.min :: range.max :: "LIMIT" :: offset :: count :: HNil).as[Arr, Seq[A]]

final def zrangebyscorewithscores[A: Bulk ==> ?](key: Key, range: ScoreRange): Protocol.Aux[Seq[(A, Double)]] =
final def zrangebyscorewithscores[A: Bulk ==> *](key: Key, range: ScoreRange): Protocol.Aux[Seq[(A, Double)]] =
Protocol("ZRANGEBYSCORE", key :: range.min :: range.max :: "WITHSCORES" :: HNil).as[Arr, Seq[(A, Double)]]
final def zrangebyscorewithscores[A: Bulk ==> ?](
final def zrangebyscorewithscores[A: Bulk ==> *](
key: Key,
range: ScoreRange,
offset: NonNegLong,
@@ -214,23 +214,23 @@ trait SortedSetBaseP {
final def zremrangebyscore(key: Key, range: ScoreRange): Protocol.Aux[NonNegInt] =
Protocol("ZREMRANGEBYSCORE", key :: range.min :: range.max :: HNil).as[Num, NonNegInt]

final def zrevrange[A: Bulk ==> ?](key: Key, start: Index, stop: Index): Protocol.Aux[Seq[A]] =
final def zrevrange[A: Bulk ==> *](key: Key, start: Index, stop: Index): Protocol.Aux[Seq[A]] =
Protocol("ZREVRANGE", key :: start :: stop :: HNil).as[Arr, Seq[A]]

final def zrevrangebylex[A: Bulk ==> ?](key: Key, range: LexRange): Protocol.Aux[Seq[A]] =
final def zrevrangebylex[A: Bulk ==> *](key: Key, range: LexRange): Protocol.Aux[Seq[A]] =
Protocol("ZREVRANGEBYLEX", key :: range.max :: range.min :: HNil).as[Arr, Seq[A]]

final def zrevrangebylex[A: Bulk ==> ?](key: Key, range: LexRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
final def zrevrangebylex[A: Bulk ==> *](key: Key, range: LexRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
Protocol("ZREVRANGEBYLEX", key :: range.max :: range.min :: "LIMIT" :: offset :: count :: HNil).as[Arr, Seq[A]]

final def zrevrangebyscore[A: Bulk ==> ?](key: Key, range: ScoreRange): Protocol.Aux[Seq[A]] =
final def zrevrangebyscore[A: Bulk ==> *](key: Key, range: ScoreRange): Protocol.Aux[Seq[A]] =
Protocol("ZREVRANGEBYSCORE", key :: range.max :: range.min :: HNil).as[Arr, Seq[A]]
final def zrevrangebyscore[A: Bulk ==> ?](key: Key, range: ScoreRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
final def zrevrangebyscore[A: Bulk ==> *](key: Key, range: ScoreRange, offset: NonNegLong, count: PosLong): Protocol.Aux[Seq[A]] =
Protocol("ZREVRANGEBYSCORE", key :: range.max :: range.min :: "LIMIT" :: offset :: count :: HNil).as[Arr, Seq[A]]

final def zrevrangebyscorewithscores[A: Bulk ==> ?](key: Key, range: ScoreRange): Protocol.Aux[Seq[(A, Double)]] =
final def zrevrangebyscorewithscores[A: Bulk ==> *](key: Key, range: ScoreRange): Protocol.Aux[Seq[(A, Double)]] =
Protocol("ZREVRANGEBYSCORE", key :: range.max :: range.min :: "WITHSCORES" :: HNil).as[Arr, Seq[(A, Double)]]
final def zrevrangebyscorewithscores[A: Bulk ==> ?](
final def zrevrangebyscorewithscores[A: Bulk ==> *](
key: Key,
range: ScoreRange,
offset: NonNegLong,
@@ -105,31 +105,31 @@ trait StringBaseP {
final def bitpos(key: Key, bit: Bit, start: Index, end: Index): Protocol.Aux[Option[NonNegInt]] =
Protocol("BITPOS", key :: bit :: start :: end :: HNil).using(minusOneIsNone)

final def decr[A: Num ==> ?](key: Key): Protocol.Aux[A] = Protocol("DECR", key).as[Num, A]
final def decr[A: Num ==> *](key: Key): Protocol.Aux[A] = Protocol("DECR", key).as[Num, A]

//TODO verify ok to limit DECRBY to only positive values, REDIS happily accepts 0 and negatives and x + (-decrement)
final def decrby[A: Num ==> ?](key: Key, decrement: PosLong): Protocol.Aux[A] = Protocol("DECRBY", key :: decrement :: HNil).as[Num, A]
final def decrby[A: Num ==> *](key: Key, decrement: PosLong): Protocol.Aux[A] = Protocol("DECRBY", key :: decrement :: HNil).as[Num, A]

final def get[A: Bulk ==> ?](key: Key): Protocol.Aux[Option[A]] = Protocol("GET", key).opt[GenBulk].as[A]
final def get[A: Bulk ==> *](key: Key): Protocol.Aux[Option[A]] = Protocol("GET", key).opt[GenBulk].as[A]

final def getbit(key: Key, offset: PosLong): Protocol.Aux[Bit] = Protocol("GETBIT", key :: offset :: HNil).as[Num, Bit]

final def getrange[A: Bulk ==> ?](key: Key, start: Index, end: Index): Protocol.Aux[A] =
final def getrange[A: Bulk ==> *](key: Key, start: Index, end: Index): Protocol.Aux[A] =
Protocol("GETRANGE", key :: start :: end :: HNil).as[Bulk, A]

final def getset[A]: PartiallyAppliedGetSet[A] = new PartiallyAppliedGetSet[A](false)

final def incr[A: Num ==> ?](key: Key): Protocol.Aux[A] = Protocol("INCR", key).as[Num, A]
final def incr[A: Num ==> *](key: Key): Protocol.Aux[A] = Protocol("INCR", key).as[Num, A]

//TODO verify ok to limit INCRBY to only positive values, REDIS happily accepts 0 and negatives
final def incrby[A: Num ==> ?](key: Key, increment: PosLong): Protocol.Aux[A] = Protocol("INCRBY", key :: increment :: HNil).as[Num, A]
final def incrby[A: Num ==> *](key: Key, increment: PosLong): Protocol.Aux[A] = Protocol("INCRBY", key :: increment :: HNil).as[Num, A]

final def incrbyfloat(key: Key, increment: NonZeroDouble): Protocol.Aux[Double] =
Protocol("INCRBYFLOAT", key :: increment :: HNil).as[Bulk, Double]

final def mget[A: Arr ==> ?](keys: OneOrMoreKeys): Protocol.Aux[A] = Protocol("MGET", keys.value).as[Arr, A]
final def mget[A: Arr ==> *](keys: OneOrMoreKeys): Protocol.Aux[A] = Protocol("MGET", keys.value).as[Arr, A]

final def mset[L <: HList: RESPParamWrite: LUBConstraint[?, (Key, _)], N <: Nat](l: L)(
final def mset[L <: HList: RESPParamWrite: LUBConstraint[*, (Key, _)], N <: Nat](l: L)(
implicit ev0: Length.Aux[L, N],
ev1: N >= _1
): Protocol.Aux[OK] = Protocol("MSET", l).as[Str, OK]
@@ -143,7 +143,7 @@ trait StringBaseP {

final def mset[A: Show](values: OneOrMore[(Key, A)]): Protocol.Aux[OK] = Protocol("MSET", values.value).as[Str, OK]

final def msetnx[L <: HList: RESPParamWrite: LUBConstraint[?, (Key, _)], N <: Nat](l: L)(
final def msetnx[L <: HList: RESPParamWrite: LUBConstraint[*, (Key, _)], N <: Nat](l: L)(
implicit ev0: Length.Aux[L, N],
ev1: N >= _1
): Protocol.Aux[Boolean] = Protocol("MSETNX", l).as[Num, Boolean]

0 comments on commit bccc5a7

Please sign in to comment.
You can’t perform that action at this time.