Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

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

Merged
merged 1 commit into from Sep 7, 2019
Merged
Changes from all commits
Commits
File filter...
Filter file types
Jump to…
Jump to file or symbol
Failed to load files and symbols.

Always

Just for now

@@ -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]
ProTip! Use n and p to navigate between commits in a pull request.
You can’t perform that action at this time.