Abstract a synchronous function with its Future counterpart - scala

Question

I wrote a very simple mechanism that only allows a max number of function calls during a given number of seconds. See it as a basic rate limiter.
It takes the execution to limit as an argument and returns the return value of that original execution.
The problem is that executions can be synchronous (of type => A) or asynchronous (of type => Future[A]) and that leads to two extremely similar functions:
case class Limiter[A](max: Int, seconds: Int) {
private val queue = Queue[Long]()
def limit(value: => A): Option[A] = {
val now = System.currentTimeMillis()
if (queue.length == max) {
val oldest = queue.head
if (now - oldest < seconds * 1000) return None
else queue.dequeue()
}
queue.enqueue(now)
Some(value)
}
def limitFuture(future: => Future[A]): Future[Option[A]] = {
val now = System.currentTimeMillis()
if (queue.length == max) {
val oldest = queue.head
if (now - oldest < seconds * 1000) return Future(None)
else queue.dequeue()
}
future.map { x =>
queue.enqueue(now)
Some(x)
}
}
}
(I am not actually using Option but a set of types I defined, just using Option for simplicity sake)
Examples of execution:
// Prevent more than 5 runs/minute. Useful for example to prevent email spamming
val limit = Limit[Boolean](5, 60)
val result = limitFuture { sendEmail(...) } // `sendEmail` returns a future
// Prevent more than 1 run/hour. Useful for example to cache HTML response
val limit = Limit[String](1, 3600)
val limit { getHTML(...) } // `getHTML` returns the HTML as a string directly
How can I refactor these methods to avoid repetition? Later needs might include other argument types and not only direct type + Futured type, so I'd like to keep my options open if it's possible.
The only "solution" I could come up with so far is to replace limit:
def limit(value: => A): Option[A] = {
Await.result(limitFuture(Future.successful(value)), 5.seconds)
}
Well, it works, but it feels backwards. I would rather have the => A being the base version that other methods extend or, even better, a generic (private) method that both limit and limitFuture could extend.
Actually, it would be even better-er if a single limit function could take care of this regardless of argument but I doubt it's possible.

Answer 1

You can condense this down to one method with an implicit parameter handling the differences:
trait Limitable[A, B] {
type Out
def none: Out
def some(b: B, f: () => Unit): Out
}
implicit def rawLimitable[A]: Limitable[A, A] = new Limitable[A, A] {
type Out = Option[A]
def none = None
def some(a: A, f: () => Unit): Out = {
f()
Some(a)
}
}
implicit def futureLimitable[A]: Limitable[A, Future[A]] = new Limitable[A, Future[A]] {
type Out = Future[Option[A]]
def none = Future(None)
def some(future: Future[A], f: () => Unit): Out = future.map { a =>
f()
Some(a)
}
}
case class Limiter[A](max: Int, seconds: Int) {
private val queue = Queue[Long]()
def limit[B](in: => B)(implicit l: Limitable[A, B]): l.Out = {
val now = System.currentTimeMillis()
if (queue.length == max) {
val oldest = queue.head
if (now - oldest < seconds * 1000) return l.none
else queue.dequeue()
}
l.some(in, {() => queue.enqueue(now)})
}
}
And use it like:
val limit = Limit[String](1, 3600)
limit.limit("foo")
limit.limit(Future("bar"))

Answer 2

You can use Applicative typeclass from cats or scalaz. Applicative, among other things, lets you lift a value into some context F (using pure) and is also a functor, so you can use map on F[A].
Currently you want it for Id and Future types (you need ExecutionContext in scope for Future applicative to work). It will work for things like Vector or Validated, tho you might have problems adding custom collection types.
import cats._, implicits._
import scala.concurrent._
import scala.collection.mutable.Queue
case class Limiter[A](max: Int, seconds: Int) {
private val queue = Queue[Long]()
def limitA[F[_]: Applicative](value: => F[A]): F[Option[A]] = {
val now = System.currentTimeMillis()
if (queue.length == max) {
val oldest = queue.head
if (now - oldest < seconds * 1000) return none[A].pure[F]
else queue.dequeue()
}
value.map { x =>
queue.enqueue(now)
x.some
}
}
// or leave these e.g. for source compatibility
def limit(value: => A): Option[A] = limitA[Id](value)
def limitFuture(future: => Future[A])(implicit ec: ExecutionContext): Future[Option[A]] = limitA(future)
}
Notes:
I'm using none[A] instead of None: Option[A] and a.some instead of Some(a): Option[A]. These helpers are available in both cats and scalaz and you need them because F[_] here is not defined as covariant.
You have to specify Id as a type explicitly, e.g. .limitA[Id](3). This is not the case with Future, however.
You map call is strange. It is parsed as:
future.map {
queue.enqueue(now) // in current thread
x => Some(x)
}
Which is the same as
queue.enqueue(now) // in current thread
future.map {
x => Some(x)
}