Skip to content

Commit 2394aff

Browse files
ethulethul
committed
Merge branch 'release-0.1.2'
2 parents 41adbb5 + 405f093 commit 2394aff

File tree

12 files changed

+182
-171
lines changed

12 files changed

+182
-171
lines changed

‎build.sbt‎

Lines changed: 28 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -2,31 +2,40 @@ organization := "com.github.ethul"
22

33
name := "redis-algebra"
44

5-
version := "0.1.1"
5+
version := "0.1.2"
66

7-
scalaVersion := "2.10.4"
7+
scalaVersion := "2.11.2"
88

9-
libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.1.0-M7"
9+
crossScalaVersions := Seq("2.10.4", "2.11.2")
1010

11-
libraryDependencies += "org.specs2" %% "specs2" % "2.2.2-scalaz-7.1.0-M3" % "test"
11+
libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.1.0"
1212

13-
resolvers += "Sonatype releases" at "https://oss.sonatype.org/content/repositories/releases/"
14-
15-
scalacOptions += "-feature"
16-
17-
scalacOptions += "-deprecation"
18-
19-
scalacOptions += "-unchecked"
13+
libraryDependencies += "org.specs2" %% "specs2" % "2.4" % "test"
2014

21-
scalacOptions += "-language:higherKinds"
22-
23-
scalacOptions += "-Xlint"
24-
25-
scalacOptions += "-Xfatal-warnings"
26-
27-
scalacOptions += "-Yno-adapted-args"
15+
resolvers += "Sonatype releases" at "https://oss.sonatype.org/content/repositories/releases/"
2816

29-
scalacOptions += "-Ywarn-all"
17+
scalacOptions ++= Seq(
18+
"-deprecation",
19+
"-encoding", "UTF-8",
20+
"-feature",
21+
"-language:higherKinds",
22+
"-language:implicitConversions",
23+
"-language:postfixOps",
24+
"-unchecked",
25+
"-Xfatal-warnings",
26+
"-Xlint:_",
27+
"-Yno-adapted-args",
28+
"-Ywarn-adapted-args",
29+
"-Ywarn-dead-code",
30+
"-Ywarn-inaccessible",
31+
"-Ywarn-infer-any",
32+
"-Ywarn-nullary-override",
33+
"-Ywarn-nullary-unit",
34+
"-Ywarn-numeric-widen",
35+
"-Ywarn-unused",
36+
"-Ywarn-unused-import",
37+
"-Ywarn-value-discard"
38+
)
3039

3140
publishTo <<= version.apply { v =>
3241
val nexus = "https://oss.sonatype.org/"

‎src/main/scala/redis/algebra/connection.scala‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package redis
22
package algebra
33

4-
import scalaz.{Free, Functor, Inject, InjectFunctions}, Free.Return
4+
import scalaz.{Free, Functor, Inject, InjectFunctions}
55

66
import data.Status
77

@@ -33,17 +33,17 @@ trait ConnectionInstances {
3333

3434
trait ConnectionFunctions extends InjectFunctions {
3535
def auth[F[_]: Functor](password: ByteString)(implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
36-
inject[F, ConnectionAlgebra, Status](Auth(password, Return(_)))
36+
inject[F, ConnectionAlgebra, Status](Auth(password, Free.point(_)))
3737

3838
def echo[F[_]: Functor](message: ByteString)(implicit I: Inject[ConnectionAlgebra, F]): Free[F, ByteString] =
39-
inject[F, ConnectionAlgebra, ByteString](Echo(message, Return(_)))
39+
inject[F, ConnectionAlgebra, ByteString](Echo(message, Free.point(_)))
4040

4141
def ping[F[_]: Functor](implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
42-
inject[F, ConnectionAlgebra, Status](Ping(Return(_)))
42+
inject[F, ConnectionAlgebra, Status](Ping(Free.point(_)))
4343

4444
def quit[F[_]: Functor](implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
45-
inject[F, ConnectionAlgebra, Status](Quit(Return(_)))
45+
inject[F, ConnectionAlgebra, Status](Quit(Free.point(_)))
4646

4747
def select[F[_]: Functor](index: Short)(implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
48-
inject[F, ConnectionAlgebra, Status](Select(index, Return(_)))
48+
inject[F, ConnectionAlgebra, Status](Select(index, Free.point(_)))
4949
}

‎src/main/scala/redis/algebra/hash.scala‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package redis
22
package algebra
33

4-
import scalaz.{Free, Functor, Inject, InjectFunctions, NonEmptyList}, Free.Return
4+
import scalaz.{Free, Functor, Inject, InjectFunctions, NonEmptyList}
55

66
import data.Status
77

@@ -57,41 +57,41 @@ trait HashInstances {
5757

5858
trait HashFunctions extends InjectFunctions {
5959
def hdel[F[_]: Functor](key: ByteString, fields: NonEmptyList[ByteString])(implicit I: Inject[HashAlgebra, F]): Free[F, Long] =
60-
inject[F, HashAlgebra, Long](Hdel(key, fields, Return(_)))
60+
inject[F, HashAlgebra, Long](Hdel(key, fields, Free.point(_)))
6161

6262
def hexists[F[_]: Functor](key: ByteString, field: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Boolean] =
63-
inject[F, HashAlgebra, Boolean](Hexists(key, field, Return(_)))
63+
inject[F, HashAlgebra, Boolean](Hexists(key, field, Free.point(_)))
6464

6565
def hget[F[_]: Functor](key: ByteString, field: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Option[ByteString]] =
66-
inject[F, HashAlgebra, Option[ByteString]](Hget(key, field, Return(_)))
66+
inject[F, HashAlgebra, Option[ByteString]](Hget(key, field, Free.point(_)))
6767

6868
def hgetall[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[(ByteString, ByteString)]] =
69-
inject[F, HashAlgebra, Seq[(ByteString, ByteString)]](Hgetall(key, Return(_)))
69+
inject[F, HashAlgebra, Seq[(ByteString, ByteString)]](Hgetall(key, Free.point(_)))
7070

7171
def hincrby[F[_]: Functor](key: ByteString, field: ByteString, increment: Long)(implicit I: Inject[HashAlgebra, F]): Free[F, Long] =
72-
inject[F, HashAlgebra, Long](Hincrby(key, field, increment, Return(_)))
72+
inject[F, HashAlgebra, Long](Hincrby(key, field, increment, Free.point(_)))
7373

7474
def hincrbyfloat[F[_]: Functor](key: ByteString, field: ByteString, increment: BigDecimal)(implicit I: Inject[HashAlgebra, F]): Free[F, BigDecimal] =
75-
inject[F, HashAlgebra, BigDecimal](Hincrbyfloat(key, field, increment, Return(_)))
75+
inject[F, HashAlgebra, BigDecimal](Hincrbyfloat(key, field, increment, Free.point(_)))
7676

7777
def hkeys[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[ByteString]] =
78-
inject[F, HashAlgebra, Seq[ByteString]](Hkeys(key, Return(_)))
78+
inject[F, HashAlgebra, Seq[ByteString]](Hkeys(key, Free.point(_)))
7979

8080
def hlen[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Long] =
81-
inject[F, HashAlgebra, Long](Hlen(key, Return(_)))
81+
inject[F, HashAlgebra, Long](Hlen(key, Free.point(_)))
8282

8383
def hmget[F[_]: Functor](key: ByteString, fields: NonEmptyList[ByteString])(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[Option[ByteString]]] =
84-
inject[F, HashAlgebra, Seq[Option[ByteString]]](Hmget(key, fields, Return(_)))
84+
inject[F, HashAlgebra, Seq[Option[ByteString]]](Hmget(key, fields, Free.point(_)))
8585

8686
def hmset[F[_]: Functor](key: ByteString, pairs: NonEmptyList[(ByteString, ByteString)])(implicit I: Inject[HashAlgebra, F]): Free[F, Status] =
87-
inject[F, HashAlgebra, Status](Hmset(key, pairs, Return(_)))
87+
inject[F, HashAlgebra, Status](Hmset(key, pairs, Free.point(_)))
8888

8989
def hset[F[_]: Functor](key: ByteString, field: ByteString, value: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Boolean] =
90-
inject[F, HashAlgebra, Boolean](Hset(key, field, value, Return(_)))
90+
inject[F, HashAlgebra, Boolean](Hset(key, field, value, Free.point(_)))
9191

9292
def hsetnx[F[_]: Functor](key: ByteString, field: ByteString, value: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Boolean] =
93-
inject[F, HashAlgebra, Boolean](Hsetnx(key, field, value, Return(_)))
93+
inject[F, HashAlgebra, Boolean](Hsetnx(key, field, value, Free.point(_)))
9494

9595
def hvals[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[ByteString]] =
96-
inject[F, HashAlgebra, Seq[ByteString]](Hvals(key, Return(_)))
96+
inject[F, HashAlgebra, Seq[ByteString]](Hvals(key, Free.point(_)))
9797
}

‎src/main/scala/redis/algebra/key.scala‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package redis
22
package algebra
33

4-
import scalaz.{\/, Free, Functor, Inject, InjectFunctions, NonEmptyList}, Free.Return
4+
import scalaz.{\/, Free, Functor, Inject, InjectFunctions, NonEmptyList}
55

66
import data.{Asc, By, Limit, ObjectSubcommand, ObjectResult, Order, Type => DataType, Status}
77

@@ -78,22 +78,22 @@ trait KeyInstances {
7878

7979
trait KeyFunctions extends InjectFunctions {
8080
def del[F[_]: Functor](keys: NonEmptyList[ByteString])(implicit I: Inject[KeyAlgebra, F]): Free[F, Long] =
81-
inject[F, KeyAlgebra, Long](Del(keys, Return(_)))
81+
inject[F, KeyAlgebra, Long](Del(keys, Free.point(_)))
8282

8383
def dump[F[_]: Functor](key: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Option[ByteString]] =
84-
inject[F, KeyAlgebra, Option[ByteString]](Dump(key, Return(_)))
84+
inject[F, KeyAlgebra, Option[ByteString]](Dump(key, Free.point(_)))
8585

8686
def exists[F[_]: Functor](key: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
87-
inject[F, KeyAlgebra, Boolean](Exists(key, Return(_)))
87+
inject[F, KeyAlgebra, Boolean](Exists(key, Free.point(_)))
8888

8989
def expire[F[_]: Functor](key: ByteString, in: Seconds)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
90-
inject[F, KeyAlgebra, Boolean](Expire(key, in, Return(_)))
90+
inject[F, KeyAlgebra, Boolean](Expire(key, in, Free.point(_)))
9191

9292
def expireat[F[_]: Functor](key: ByteString, at: Seconds)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
93-
inject[F, KeyAlgebra, Boolean](Expireat(key, at, Return(_)))
93+
inject[F, KeyAlgebra, Boolean](Expireat(key, at, Free.point(_)))
9494

9595
def keys[F[_]: Functor](pattern: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Seq[ByteString]] =
96-
inject[F, KeyAlgebra, Seq[ByteString]](Keys(pattern, Return(_)))
96+
inject[F, KeyAlgebra, Seq[ByteString]](Keys(pattern, Free.point(_)))
9797

9898
def migrate[F[_]: Functor](
9999
host: ByteString,
@@ -103,37 +103,37 @@ trait KeyFunctions extends InjectFunctions {
103103
destination: Short,
104104
copy: Boolean = false,
105105
replace: Boolean = false)(implicit I: Inject[KeyAlgebra, F]): Free[F, Status] =
106-
inject[F, KeyAlgebra, Status](Migrate(host, port, key, timeout, destination, copy, replace, Return(_)))
106+
inject[F, KeyAlgebra, Status](Migrate(host, port, key, timeout, destination, copy, replace, Free.point(_)))
107107

108108
def move[F[_]: Functor](key: ByteString, db: Short)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
109-
inject[F, KeyAlgebra, Boolean](Move(key, db, Return(_)))
109+
inject[F, KeyAlgebra, Boolean](Move(key, db, Free.point(_)))
110110

111111
def `object`[F[_]: Functor](subcommand: ObjectSubcommand)(implicit I: Inject[KeyAlgebra, F]): Free[F, Option[ObjectResult]] =
112-
inject[F, KeyAlgebra, Option[ObjectResult]](Object(subcommand, Return(_)))
112+
inject[F, KeyAlgebra, Option[ObjectResult]](Object(subcommand, Free.point(_)))
113113

114114
def persist[F[_]: Functor](key: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
115-
inject[F, KeyAlgebra, Boolean](Persist(key, Return(_)))
115+
inject[F, KeyAlgebra, Boolean](Persist(key, Free.point(_)))
116116

117117
def pexpire[F[_]: Functor](key: ByteString, in: Milliseconds)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
118-
inject[F, KeyAlgebra, Boolean](Pexpire(key, in, Return(_)))
118+
inject[F, KeyAlgebra, Boolean](Pexpire(key, in, Free.point(_)))
119119

120120
def pexpireat[F[_]: Functor](key: ByteString, at: Milliseconds)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
121-
inject[F, KeyAlgebra, Boolean](Pexpireat(key, at, Return(_)))
121+
inject[F, KeyAlgebra, Boolean](Pexpireat(key, at, Free.point(_)))
122122

123123
def pttl[F[_]: Functor](key: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Option[Milliseconds]] =
124-
inject[F, KeyAlgebra, Option[Milliseconds]](Pttl(key, Return(_)))
124+
inject[F, KeyAlgebra, Option[Milliseconds]](Pttl(key, Free.point(_)))
125125

126126
def randomkey[F[_]: Functor](implicit I: Inject[KeyAlgebra, F]): Free[F, Option[ByteString]] =
127-
inject[F, KeyAlgebra, Option[ByteString]](Randomkey(Return(_)))
127+
inject[F, KeyAlgebra, Option[ByteString]](Randomkey(Free.point(_)))
128128

129129
def rename[F[_]: Functor](key: ByteString, name: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Status] =
130-
inject[F, KeyAlgebra, Status](Rename(key, name, Return(_)))
130+
inject[F, KeyAlgebra, Status](Rename(key, name, Free.point(_)))
131131

132132
def renamenx[F[_]: Functor](key: ByteString, name: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Boolean] =
133-
inject[F, KeyAlgebra, Boolean](Renamenx(key, name, Return(_)))
133+
inject[F, KeyAlgebra, Boolean](Renamenx(key, name, Free.point(_)))
134134

135135
def restore[F[_]: Functor](key: ByteString, value: ByteString, ttl: Option[Milliseconds] = None)(implicit I: Inject[KeyAlgebra, F]): Free[F, Status] =
136-
inject[F, KeyAlgebra, Status](Restore(key, ttl, value, Return(_)))
136+
inject[F, KeyAlgebra, Status](Restore(key, ttl, value, Free.point(_)))
137137

138138
def sort[F[_]: Functor](
139139
key: ByteString,
@@ -143,11 +143,11 @@ trait KeyFunctions extends InjectFunctions {
143143
order: Order = Asc,
144144
alpha: Boolean = false,
145145
store: Option[ByteString] = None)(implicit I: Inject[KeyAlgebra, F]): Free[F, Seq[ByteString] \/ Long] =
146-
inject[F, KeyAlgebra, Seq[ByteString] \/ Long](Sort(key, by, limit, get, order, alpha, store, Return(_)))
146+
inject[F, KeyAlgebra, Seq[ByteString] \/ Long](Sort(key, by, limit, get, order, alpha, store, Free.point(_)))
147147

148148
def ttl[F[_]: Functor](key: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Option[Seconds]] =
149-
inject[F, KeyAlgebra, Option[Seconds]](Ttl(key, Return(_)))
149+
inject[F, KeyAlgebra, Option[Seconds]](Ttl(key, Free.point(_)))
150150

151151
def `type`[F[_]: Functor](key: ByteString)(implicit I: Inject[KeyAlgebra, F]): Free[F, Option[DataType]] =
152-
inject[F, KeyAlgebra, Option[DataType]](Type(key, Return(_)))
152+
inject[F, KeyAlgebra, Option[DataType]](Type(key, Free.point(_)))
153153
}

‎src/main/scala/redis/algebra/list.scala‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package redis
22
package algebra
33

4-
import scalaz.{Free, Functor, Inject, InjectFunctions, NonEmptyList}, Free.Return
4+
import scalaz.{Free, Functor, Inject, InjectFunctions, NonEmptyList}
55

66
import data.{Asc, Position, Status}
77

@@ -69,53 +69,53 @@ trait ListInstances {
6969

7070
trait ListFunctions extends InjectFunctions {
7171
def blpop[F[_]: Functor](keys: NonEmptyList[ByteString], timeout: Seconds)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[(ByteString, ByteString)]] =
72-
inject[F, ListAlgebra, Option[(ByteString, ByteString)]](Blpop(keys, timeout, Return(_)))
72+
inject[F, ListAlgebra, Option[(ByteString, ByteString)]](Blpop(keys, timeout, Free.point(_)))
7373

7474
def brpop[F[_]: Functor](keys: NonEmptyList[ByteString], timeout: Seconds)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[(ByteString, ByteString)]] =
75-
inject[F, ListAlgebra, Option[(ByteString, ByteString)]](Brpop(keys, timeout, Return(_)))
75+
inject[F, ListAlgebra, Option[(ByteString, ByteString)]](Brpop(keys, timeout, Free.point(_)))
7676

7777
def brpoplpush[F[_]: Functor](source: ByteString, destination: ByteString, timeout: Seconds)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[ByteString]] =
78-
inject[F, ListAlgebra, Option[ByteString]](Brpoplpush(source, destination, timeout, Return(_)))
78+
inject[F, ListAlgebra, Option[ByteString]](Brpoplpush(source, destination, timeout, Free.point(_)))
7979

8080
def lindex[F[_]: Functor](key: ByteString, index: Long)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[ByteString]] =
81-
inject[F, ListAlgebra, Option[ByteString]](Lindex(key, index, Return(_)))
81+
inject[F, ListAlgebra, Option[ByteString]](Lindex(key, index, Free.point(_)))
8282

8383
def linsert[F[_]: Functor](key: ByteString, position: Position, pivot: ByteString, value: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[Long]] =
84-
inject[F, ListAlgebra, Option[Long]](Linsert(key, position, pivot, value, Return(_)))
84+
inject[F, ListAlgebra, Option[Long]](Linsert(key, position, pivot, value, Free.point(_)))
8585

8686
def llen[F[_]: Functor](key: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Long] =
87-
inject[F, ListAlgebra, Long](Llen(key, Return(_)))
87+
inject[F, ListAlgebra, Long](Llen(key, Free.point(_)))
8888

8989
def lpop[F[_]: Functor](key: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[ByteString]] =
90-
inject[F, ListAlgebra, Option[ByteString]](Lpop(key, Return(_)))
90+
inject[F, ListAlgebra, Option[ByteString]](Lpop(key, Free.point(_)))
9191

9292
def lpush[F[_]: Functor](key: ByteString, values: NonEmptyList[ByteString])(implicit I: Inject[ListAlgebra, F]): Free[F, Long] =
93-
inject[F, ListAlgebra, Long](Lpush(key, values, Return(_)))
93+
inject[F, ListAlgebra, Long](Lpush(key, values, Free.point(_)))
9494

9595
def lpushx[F[_]: Functor](key: ByteString, value: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Long] =
96-
inject[F, ListAlgebra, Long](Lpushx(key, value, Return(_)))
96+
inject[F, ListAlgebra, Long](Lpushx(key, value, Free.point(_)))
9797

9898
def lrange[F[_]: Functor](key: ByteString, start: Long, stop: Long)(implicit I: Inject[ListAlgebra, F]): Free[F, Seq[ByteString]] =
99-
inject[F, ListAlgebra, Seq[ByteString]](Lrange(key, start, stop, Return(_)))
99+
inject[F, ListAlgebra, Seq[ByteString]](Lrange(key, start, stop, Free.point(_)))
100100

101101
def lrem[F[_]: Functor](key: ByteString, count: Long, value: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Long] =
102-
inject[F, ListAlgebra, Long](Lrem(key, count, value, Return(_)))
102+
inject[F, ListAlgebra, Long](Lrem(key, count, value, Free.point(_)))
103103

104104
def lset[F[_]: Functor](key: ByteString, index: Long, value: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Status] =
105-
inject[F, ListAlgebra, Status](Lset(key, index, value, Return(_)))
105+
inject[F, ListAlgebra, Status](Lset(key, index, value, Free.point(_)))
106106

107107
def ltrim[F[_]: Functor](key: ByteString, start: Long, stop: Long)(implicit I: Inject[ListAlgebra, F]): Free[F, Status] =
108-
inject[F, ListAlgebra, Status](Ltrim(key, start, stop, Return(_)))
108+
inject[F, ListAlgebra, Status](Ltrim(key, start, stop, Free.point(_)))
109109

110110
def rpop[F[_]: Functor](key: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[ByteString]] =
111-
inject[F, ListAlgebra, Option[ByteString]](Rpop(key, Return(_)))
111+
inject[F, ListAlgebra, Option[ByteString]](Rpop(key, Free.point(_)))
112112

113113
def rpoplpush[F[_]: Functor](source: ByteString, destination: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Option[ByteString]] =
114-
inject[F, ListAlgebra, Option[ByteString]](Rpoplpush(source, destination, Return(_)))
114+
inject[F, ListAlgebra, Option[ByteString]](Rpoplpush(source, destination, Free.point(_)))
115115

116116
def rpush[F[_]: Functor](key: ByteString, values: NonEmptyList[ByteString])(implicit I: Inject[ListAlgebra, F]): Free[F, Long] =
117-
inject[F, ListAlgebra, Long](Rpush(key, values, Return(_)))
117+
inject[F, ListAlgebra, Long](Rpush(key, values, Free.point(_)))
118118

119119
def rpushx[F[_]: Functor](key: ByteString, value: ByteString)(implicit I: Inject[ListAlgebra, F]): Free[F, Long] =
120-
inject[F, ListAlgebra, Long](Rpushx(key, value, Return(_)))
120+
inject[F, ListAlgebra, Long](Rpushx(key, value, Free.point(_)))
121121
}

‎src/main/scala/redis/algebra/script.scala‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package redis
22
package algebra
33

4-
import scalaz.{\/, Free, Functor, Inject, InjectFunctions, NonEmptyList}, Free.Return
4+
import scalaz.{\/, Free, Functor, Inject, InjectFunctions, NonEmptyList}
55

66
import data.{LuaResult, Status}
77

@@ -39,23 +39,23 @@ trait ScriptFunctions extends InjectFunctions {
3939
script: ByteString,
4040
keys: Seq[ByteString] = Nil,
4141
args: Seq[ByteString] = Nil)(implicit I: Inject[ScriptAlgebra, F]): Free[F, LuaResult] =
42-
inject[F, ScriptAlgebra, LuaResult](Eval(script, keys, args, Return(_)))
42+
inject[F, ScriptAlgebra, LuaResult](Eval(script, keys, args, Free.point(_)))
4343

4444
def evalsha[F[_]: Functor](
4545
sha1: ByteString,
4646
keys: Seq[ByteString] = Nil,
4747
args: Seq[ByteString] = Nil)(implicit I: Inject[ScriptAlgebra, F]): Free[F, LuaResult] =
48-
inject[F, ScriptAlgebra, LuaResult](Evalsha(sha1, keys, args, Return(_)))
48+
inject[F, ScriptAlgebra, LuaResult](Evalsha(sha1, keys, args, Free.point(_)))
4949

5050
def scriptexists[F[_]: Functor](scripts: NonEmptyList[ByteString])(implicit I: Inject[ScriptAlgebra, F]): Free[F, NonEmptyList[Boolean]] =
51-
inject[F, ScriptAlgebra, NonEmptyList[Boolean]](Scriptexists(scripts, Return(_)))
51+
inject[F, ScriptAlgebra, NonEmptyList[Boolean]](Scriptexists(scripts, Free.point(_)))
5252

5353
def scriptflush[F[_]: Functor](implicit I: Inject[ScriptAlgebra, F]): Free[F, Status] =
54-
inject[F, ScriptAlgebra, Status](Scriptflush(Return(_)))
54+
inject[F, ScriptAlgebra, Status](Scriptflush(Free.point(_)))
5555

5656
def scriptkill[F[_]: Functor](implicit I: Inject[ScriptAlgebra, F]): Free[F, Status] =
57-
inject[F, ScriptAlgebra, Status](Scriptkill(Return(_)))
57+
inject[F, ScriptAlgebra, Status](Scriptkill(Free.point(_)))
5858

5959
def scriptload[F[_]: Functor](script: ByteString)(implicit I: Inject[ScriptAlgebra, F]): Free[F, Option[ByteString]] =
60-
inject[F, ScriptAlgebra, Option[ByteString]](Scriptload(script, Return(_)))
60+
inject[F, ScriptAlgebra, Option[ByteString]](Scriptload(script, Free.point(_)))
6161
}

0 commit comments

Comments
 (0)