Mortimerp9

  import scala.slick.driver....simple._
  import com.twitter.util.Time
  
  class TimeTable(tag: Tag) extends Table[(Int, Time)](tag, "timetable") {

      implicit val twitterTimeMap = MappedColumnType.base[Time, Long](
          { time => time.inMillis },
          { millis => Time.fromMilliseconds(millis) }
      )
  

Mortimerp9

import com.fasterxml.jackson.core._

object ScalaJson {
  
  lazy val factory = new JsonFactory()
  
  
  implicit  class JsonString(json: String) {
    def jsonField(name: String) = ScalaJson.getFieldOnly(name, json)
  }

Mortimerp9

case object IdentifyTimeout

class MyActor extends Actor {
 
  var driver: ActorRef = null
  val identifyId = //get a unique identifyId for that driverUrl
 
  override def  preStart() {
    val driverSel = context.actorSelection(driverUrl)
    driverSel ! Identify(identifyId)

Mortimerp9

class MyActor extends Actor {

  var driver: ActorRef = null
  val identifyId = //get a unique identifyId for that driverUrl

  override def  preStart() {
    val driverSel = context.actorSelection(driverUrl)
    driverSel ! Identify(identifyId)
  }

Mortimerp9

trait Animal
private class Dog extends Animal
private class Cat extends Animal

trait Wanna
case object WannaCat extends Wanna
case object WannaDog extends Wanna

trait AnimalFactory[Wanna] {
  def create(): Animal

Mortimerp9

import scala.util.{Failure, Success, Try}
import scala.concurrent.future

implicit def tryToFuture[T](t: Try[T]): Future[T] = t match {
    case Success(s) => Future.successful(s)
    case Failure(t) => Future.failed(t)
  }

Mortimerp9

import scala.concurrent.duration.{Duration => ScalaDuration}
import scala.concurrent.{ExecutionContext => ScalaExecutionContext, Future => ScalaFuture, Promise => ScalaPromise}
import scala.util.{Success, Failure}

import akka.dispatch.{ExecutionContext => AkkaExecutionContext, Future => AkkaFuture, Promise => AkkaPromise}
import akka.util.{Duration => AkkaDuration}

/**
 * Some compatibility implicit conversions to deal with akka as if it might already be a newer version
 * (using scala interfaces instead of akka).

Mortimerp9

#Bounded Memoizer

As an exercise, I was trying to implement a memoization of single parameter functions with a bounded cache size; a very simple approach with a First In First Out strategy. It's probably not perfect, let me know what you think of it.

The specs are that the memoizer should be concurrent and kick out the "oldest" computation. For instance, with a maximum size of 2 slots in the cache:

  foo(0) //computes and cache the result for 0
  foo(1) //computes and cache the result for 1
  foo(0) // returns the cached result
 foo(2) // computes and cache the result for 2 and kicks out the result for 0)

Mortimerp9

import scala.reflect.ClassTag
import scala.collection.mutable.WrappedArray
import scala.collection.mutable.ArrayLike

def ASeq[T](elt: T*)(implicit ct: ClassTag[T]): IndexedSeq[T] = {
   val a = elt.toArray.clone
   a.deep.asInstanceOf[IndexedSeq[T]]
}                                                 

val a = Array(1,2,3)                              //> a  : Array[Int] = Array(1, 2, 3)

Mortimerp9

import scala.concurrent.Await
import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import scala.concurrent.blocking
import scala.concurrent.duration.Deadline
import scala.concurrent.duration.Duration
import scala.concurrent.duration.DurationInt
import scala.concurrent.duration.DurationLong
import scala.concurrent.future
import scala.concurrent.promise