CacheのEffInterpreter実装

CacheIOInterpreter.scala

trait CacheIOInterpreter {

  // Effects of type R, returning a value of type A
  def run[R, U, A](effects: Eff[R, A])(
    implicit m: Member.Aux[CacheIO, R, U],
    m1: _readerRedisClient[U],
    m2: _writerLogMsg[U],
    m3: _errorEither[U],
    m4: _task[U]
  ): Eff[U, A] = {

    translate(effects)(new Translate[CacheIO, U] {
      def apply[X](kv: CacheIO[X]): Eff[U, X] = {

        kv match {
          case x: Put[X] =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Put(${x.key}, ${x.value})"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask(redisClient.put(x.key, x.value, x.expireSecond)(x.fmt))
              r2          <- fromEsError[U, X](r1)
            } yield r2
          case xs: PutList[X] =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"PutList(${xs.key}, ${xs.values})"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask(redisClient.putList(xs.key, xs.values, xs.expireSecond)(xs.fmt))
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
          case Get(key, fmt) =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Get($key)"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask(redisClient.get(key)(fmt))
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
          case GetList(key, fmt) =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Get($key)"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask(redisClient.getList(key)(fmt))
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
          case Scan(keyGlob, fmt) =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Scan($keyGlob)"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask(redisClient.scan(keyGlob)(fmt))
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
          case ScanOne(keyGlob, fmt) =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"ScanOne($keyGlob)"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask(redisClient.scan(keyGlob.some)(fmt))
              r2 <- {
                val res = r1.map { x =>
                  x.size match {
                    case 0 => None.asInstanceOf[X]
                    case 1 => x.headOption.asInstanceOf[X]
                    case _ =>
                      EsLogger.warn(
                        "cache",
                        Map(
                          "msg"  -> s"not be able to squeeze in one",
                          "res"  -> s"${x.toString}",
                          "size" -> s"${x.size}"
                        )
                      )
                      x.headOption.asInstanceOf[X]
                  }
                }
                fromEsError[U, X](res)
              }
            } yield r2
          case Delete(key) =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Delete($key)"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask[U, \/[EsError, Unit]](redisClient.delete(key))
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
          case Has(key) =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Has($key)"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask[U, \/[EsError, Boolean]](redisClient.exists(key))
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
          case Clear =>
            for {
              _           <- tell[U, LogMessage](LogMessage(s"Clear"))
              redisClient <- ask[U, RedisClient]
              r1          <- fromTask[U, \/[EsError, Unit]](redisClient.clear)
              r2          <- fromEsError[U, X](r1.map(_.asInstanceOf[X]))
            } yield r2
        }
      }
    })
  }

}