Merge branch 'release-0.1.0'

Author: ethul

README.md

@@ -1 +1,47 @@
 # Redis Algebra
+
+A Redis library for Scala that is built on Scalaz's free monad implementation, designed in the spirit of Swierstra's [Data types a la carte](http://www.staff.science.uu.nl/~swier004/Publications/DataTypesALaCarte.pdf). The library is intended to be used in combination with other free monad based libraries to build rich algebras tailored to the user's needs.
+
+The functions that this library provides correspond to the list of [Redis commands](http://redis.io/commands). In order to run programs that have been written using this library, an interpreter needs to be implemented to handle each of the commands. There is no interpreter included by default; however, one may be made available in a separate repository. Interpreters may be interchanged freely based on the user's desired behaviour. For instance, a non-blocking interpreter that sends commands to Redis may be used in production, while an interpreter that uses an in-memory representation may be used when running tests.
+
+# Install
+
+Releases and snapshots of the Redis Algebra library are published to the [Sonatype OSS Repository Hosting Service](https://oss.sonatype.org). The necessary [SBT Resolvers](http://www.scala-sbt.org/release/docs/Detailed-Topics/Resolvers.html) may be added as follows to your SBT build file.
+
+```scala
+resolvers += "Sonatype releases" at "http://oss.sonatype.org/content/repositories/releases/"
+
+resolvers += "Sonatype snapshots" at "http://oss.sonatype.org/content/repositories/snapshots/"
+```
+
+# Usage
+
+```scala
+import scala.language.implicitConversions
+import scalaz.{CharSet, NonEmptyList}, NonEmptyList.nels
+import scalaz.std.list._
+import scalaz.syntax.{Ops, monad, traverse}, monad._, traverse._
+
+import redis.algebra.{F, R}
+import redis.algebra.all._
+
+val e0 =
+  set[R]("key".utf8, "value".utf8) >>
+  get[R]("key".utf8)
+
+val e1 =
+  set[R]("counter".utf8, 100L.utf8) >>
+  incr[R]("counter".utf8) >>
+  incr[R]("counter".utf8) >>
+  incrby[R]("counter".utf8, 10L)
+
+val e2 =
+  List("first".utf8, "second".utf8, "third".utf8).map(a => rpush[R]("messages".utf8, nels(a))).sequenceU >>
+  lrange[R]("messages".utf8, 0, 2)
+
+implicit def StringToStringOps(a: String): StringOps = new StringOps { val self = a }
+
+implicit def LongToStringOps(a: Long): StringOps = new StringOps { val self = a.toString }
+
+sealed abstract class StringOps extends Ops[String] { final def utf8 = self.getBytes(CharSet.UTF8).toIndexedSeq }
+```

build.sbt

@@ -0,0 +1,64 @@
+organization := "com.github.ethul"
+
+name := "redis-algebra"
+
+version := "0.1.0"
+
+scalaVersion := "2.10.4"
+
+libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.1.0-M7"
+
+libraryDependencies += "org.specs2" %% "specs2" % "2.2.2-scalaz-7.1.0-M3" % "test"
+
+resolvers += "Sonatype releases" at "https://oss.sonatype.org/content/repositories/releases/"
+
+resolvers += "Sonatype snapshots" at "https://oss.sonatype.org/content/repositories/snapshots/"
+
+scalacOptions += "-feature"
+
+scalacOptions += "-deprecation"
+
+scalacOptions += "-unchecked"
+
+scalacOptions += "-language:higherKinds"
+
+scalacOptions += "-Xlint"
+
+scalacOptions += "-Xfatal-warnings"
+
+scalacOptions += "-Yno-adapted-args"
+
+scalacOptions += "-Ywarn-all"
+
+publishTo <<= version.apply { v =>
+  val nexus = "https://oss.sonatype.org/"
+  if (v.trim.endsWith("SNAPSHOT"))
+    Some("Snapshots" at nexus + "content/repositories/snapshots")
+  else
+    Some("Releases" at nexus + "service/local/staging/deploy/maven2")
+}
+
+credentials += Credentials(Path.userHome / ".ivy2" / ".credentials")
+
+pomIncludeRepository := Function.const(false)
+
+pomExtra :=
+  <licenses>
+    <license>
+      <name>MIT</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <scm>
+    <url>https://github.com/ethul/redis-algebra</url>
+    <connection>scm:git:git@github.com:ethul/redis-algebra.git</connection>
+    <developerConnection>scm:git:git@github.com:ethul/redis-algebra.git</developerConnection>
+  </scm>
+  <developers>
+    <developer>
+      <id>ethul</id>
+      <name>Eric Thul</name>
+      <url>https://github.com/ethul</url>
+    </developer>
+  </developers>

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.5

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

@@ -0,0 +1,49 @@
+package redis
+package algebra
+
+import scalaz.{Free, Functor, Inject, InjectFunctions}, Free.Return
+
+import data.Status
+
+sealed abstract class ConnectionAlgebra[A]
+
+final case class Auth[A](password: ByteString, h: Status => A) extends ConnectionAlgebra[A]
+
+final case class Echo[A](message: ByteString, h: ByteString => A) extends ConnectionAlgebra[A]
+
+final case class Ping[A](h: Status => A) extends ConnectionAlgebra[A]
+
+final case class Quit[A](h: Status => A) extends ConnectionAlgebra[A]
+
+final case class Select[A](index: Short, h: Status => A) extends ConnectionAlgebra[A]
+
+trait ConnectionInstances {
+  implicit val connectionAlgebraFunctor: Functor[ConnectionAlgebra] =
+    new Functor[ConnectionAlgebra] {
+      def map[A, B](a: ConnectionAlgebra[A])(f: A => B): ConnectionAlgebra[B] =
+        a match {
+          case Auth(p, h) => Auth(p, x => f(h(x)))
+          case Echo(m, h) => Echo(m, x => f(h(x)))
+          case Ping(h) => Ping(x => f(h(x)))
+          case Quit(h) => Quit(x => f(h(x)))
+          case Select(i, h) => Select(i, x => f(h(x)))
+        }
+    }
+}
+
+trait ConnectionFunctions extends InjectFunctions {
+  def auth[F[_]: Functor](password: ByteString)(implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
+    inject[F, ConnectionAlgebra, Status](Auth(password, Return(_)))
+
+  def echo[F[_]: Functor](message: ByteString)(implicit I: Inject[ConnectionAlgebra, F]): Free[F, ByteString] =
+    inject[F, ConnectionAlgebra, ByteString](Echo(message, Return(_)))
+
+  def ping[F[_]: Functor](implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
+    inject[F, ConnectionAlgebra, Status](Ping(Return(_)))
+
+  def quit[F[_]: Functor](implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
+    inject[F, ConnectionAlgebra, Status](Quit(Return(_)))
+
+  def select[F[_]: Functor](index: Short)(implicit I: Inject[ConnectionAlgebra, F]): Free[F, Status] =
+    inject[F, ConnectionAlgebra, Status](Select(index, Return(_)))
+}

src/main/scala/redis/algebra/data.scala

@@ -0,0 +1,83 @@
+package redis
+package algebra
+package data
+
+import scalaz.NonEmptyList
+
+sealed abstract class Status
+case object Ok extends Status
+case object Error extends Status
+case object Wrongtype extends Status
+
+sealed abstract class Type
+case object String extends Type
+case object List extends Type
+case object Set extends Type
+case object ZSet extends Type
+case object Hash extends Type
+
+sealed abstract class ObjectSubcommand
+final case class Refcount(key: ByteString) extends ObjectSubcommand
+final case class Encoding(key: ByteString) extends ObjectSubcommand
+final case class Idletime(key: ByteString) extends ObjectSubcommand
+
+sealed abstract class ObjectResult
+final case class RefcountResult(value: Long) extends ObjectResult
+final case class EncodingResult(value: ByteString) extends ObjectResult
+final case class IdletimeResult(value: Long) extends ObjectResult
+
+sealed abstract class LuaResult
+final case class LuaNumber(value: Long) extends LuaResult
+final case class LuaString(value: ByteString) extends LuaResult
+final case class LuaTable(value: Seq[ByteString]) extends LuaResult
+final case class LuaStatus(value: Status) extends LuaResult
+final case class LuaBoolean(value: Boolean) extends LuaResult
+
+sealed abstract class Master
+final case class Host(name: ByteString, port: Int) extends Master
+case object Noone extends Master
+
+sealed abstract class SlowlogSubcommand
+final case class Get(limit: Option[Int] = None) extends SlowlogSubcommand
+case object Len extends SlowlogSubcommand
+case object Reset extends SlowlogSubcommand
+
+sealed abstract class SlowlogResult
+final case class GetResult(value: Seq[ByteString]) extends SlowlogResult
+final case class LenResult(value: Int) extends SlowlogResult
+case object ResetResult extends SlowlogResult
+
+sealed abstract class BitOperation
+final case class And(dest: ByteString, keys: NonEmptyList[ByteString]) extends BitOperation
+final case class Or(dest: ByteString, keys: NonEmptyList[ByteString]) extends BitOperation
+final case class Xor(dest: ByteString, keys: NonEmptyList[ByteString]) extends BitOperation
+final case class Not(dest: ByteString, key: ByteString) extends BitOperation
+
+sealed abstract class SetOption
+case object Nx extends SetOption
+case object Xx extends SetOption
+
+sealed abstract class Endpoint
+final case class Closed(value: Double) extends Endpoint
+final case class Open(value: Double) extends Endpoint
+case object -∞ extends Endpoint
+case object +∞ extends Endpoint
+
+sealed abstract class Aggregate
+case object Sum extends Aggregate
+case object Min extends Aggregate
+case object Max extends Aggregate
+
+sealed abstract class Order
+case object Asc extends Order
+case object Desc extends Order
+
+sealed abstract class Position
+case object Before extends Position
+case object After extends Position
+
+sealed abstract class By
+case object Nosort extends By
+final case class Pattern(pattern: ByteString) extends By
+
+final case class Limit(offset: Long, count: Long)

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

@@ -0,0 +1,97 @@
+package redis
+package algebra
+
+import scalaz.{Free, Functor, Inject, InjectFunctions, NonEmptyList}, Free.Return
+
+import data.Status
+
+sealed abstract class HashAlgebra[A]
+
+final case class Hdel[A](key: ByteString, fields: NonEmptyList[ByteString], h: Long => A) extends HashAlgebra[A]
+
+final case class Hexists[A](key: ByteString, field: ByteString, h: Boolean => A) extends HashAlgebra[A]
+
+final case class Hget[A](key: ByteString, field: ByteString, h: Option[ByteString] => A) extends HashAlgebra[A]
+
+final case class Hgetall[A](key: ByteString, h: Seq[(ByteString, ByteString)] => A) extends HashAlgebra[A]
+
+final case class Hincrby[A](key: ByteString, field: ByteString, increment: Long, h: Long => A) extends HashAlgebra[A]
+
+final case class Hincrbyfloat[A](key: ByteString, field: ByteString, increment: BigDecimal, h: BigDecimal => A) extends HashAlgebra[A]
+
+final case class Hkeys[A](key: ByteString, h: Seq[ByteString] => A) extends HashAlgebra[A]
+
+final case class Hlen[A](key: ByteString, h: Long => A) extends HashAlgebra[A]
+
+final case class Hmget[A](key: ByteString, fields: NonEmptyList[ByteString], h: Seq[Option[ByteString]] => A) extends HashAlgebra[A]
+
+final case class Hmset[A](key: ByteString, pairs: NonEmptyList[(ByteString, ByteString)], h: Status => A) extends HashAlgebra[A]
+
+final case class Hset[A](key: ByteString, field: ByteString, value: ByteString, h: Boolean => A) extends HashAlgebra[A]
+
+final case class Hsetnx[A](key: ByteString, field: ByteString, value: ByteString, h: Boolean => A) extends HashAlgebra[A]
+
+final case class Hvals[A](key: ByteString, h: Seq[ByteString] => A) extends HashAlgebra[A]
+
+trait HashInstances {
+  implicit val hashAlgebraFunctor: Functor[HashAlgebra] =
+    new Functor[HashAlgebra] {
+      def map[A, B](a: HashAlgebra[A])(f: A => B): HashAlgebra[B] =
+        a match {
+          case Hdel(k, s, h) => Hdel(k, s, x => f(h(x)))
+          case Hexists(k, s, h) => Hexists(k, s, x => f(h(x)))
+          case Hget(k, s, h) => Hget(k, s, x => f(h(x)))
+          case Hgetall(k, h) => Hgetall(k, x => f(h(x)))
+          case Hincrby(k, s, i, h) => Hincrby(k, s, i, x => f(h(x)))
+          case Hincrbyfloat(k, s, i, h) => Hincrbyfloat(k, s, i, x => f(h(x)))
+          case Hkeys(k, h) => Hkeys(k, x => f(h(x)))
+          case Hlen(k, h) => Hlen(k, x => f(h(x)))
+          case Hmget(k, s, h) => Hmget(k, s, x => f(h(x)))
+          case Hmset(k, p, h) => Hmset(k, p, x => f(h(x)))
+          case Hset(k, s, v, h) => Hset(k, s, v, x => f(h(x)))
+          case Hsetnx(k, s, v, h) => Hsetnx(k, s, v, x => f(h(x)))
+          case Hvals(k, h) => Hvals(k, x => f(h(x)))
+        }
+    }
+}
+
+trait HashFunctions extends InjectFunctions {
+  def hdel[F[_]: Functor](key: ByteString, fields: NonEmptyList[ByteString])(implicit I: Inject[HashAlgebra, F]): Free[F, Long] =
+    inject[F, HashAlgebra, Long](Hdel(key, fields, Return(_)))
+
+  def hexists[F[_]: Functor](key: ByteString, field: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Boolean] =
+    inject[F, HashAlgebra, Boolean](Hexists(key, field, Return(_)))
+
+  def hget[F[_]: Functor](key: ByteString, field: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Option[ByteString]] =
+    inject[F, HashAlgebra, Option[ByteString]](Hget(key, field, Return(_)))
+
+  def hgetall[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[(ByteString, ByteString)]] =
+    inject[F, HashAlgebra, Seq[(ByteString, ByteString)]](Hgetall(key, Return(_)))
+
+  def hincrby[F[_]: Functor](key: ByteString, field: ByteString, increment: Long)(implicit I: Inject[HashAlgebra, F]): Free[F, Long] =
+    inject[F, HashAlgebra, Long](Hincrby(key, field, increment, Return(_)))
+
+  def hincrbyfloat[F[_]: Functor](key: ByteString, field: ByteString, increment: BigDecimal)(implicit I: Inject[HashAlgebra, F]): Free[F, BigDecimal] =
+    inject[F, HashAlgebra, BigDecimal](Hincrbyfloat(key, field, increment, Return(_)))
+
+  def hkeys[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[ByteString]] =
+    inject[F, HashAlgebra, Seq[ByteString]](Hkeys(key, Return(_)))
+
+  def hlen[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Long] =
+    inject[F, HashAlgebra, Long](Hlen(key, Return(_)))
+
+  def hmget[F[_]: Functor](key: ByteString, fields: NonEmptyList[ByteString])(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[Option[ByteString]]] =
+    inject[F, HashAlgebra, Seq[Option[ByteString]]](Hmget(key, fields, Return(_)))
+
+  def hmset[F[_]: Functor](key: ByteString, pairs: NonEmptyList[(ByteString, ByteString)])(implicit I: Inject[HashAlgebra, F]): Free[F, Status] =
+    inject[F, HashAlgebra, Status](Hmset(key, pairs, Return(_)))
+
+  def hset[F[_]: Functor](key: ByteString, field: ByteString, value: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Boolean] =
+    inject[F, HashAlgebra, Boolean](Hset(key, field, value, Return(_)))
+
+  def hsetnx[F[_]: Functor](key: ByteString, field: ByteString, value: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Boolean] =
+    inject[F, HashAlgebra, Boolean](Hsetnx(key, field, value, Return(_)))
+
+  def hvals[F[_]: Functor](key: ByteString)(implicit I: Inject[HashAlgebra, F]): Free[F, Seq[ByteString]] =
+    inject[F, HashAlgebra, Seq[ByteString]](Hvals(key, Return(_)))
+}