Revert "Merge pull request lichess-org#3666 from isaacl/anyvalSteroids"

This reverts commit 22a3ec7, reversing
changes made to a081a9d.

app/templating/Environment.scala

@@ -9,7 +9,15 @@ import play.twirl.api.Html
 import lila.api.Env.{ current => apiEnv }
 
 object Environment
-  extends lila.Steroids
+  extends scalaz.syntax.ToIdOps
+  with scalaz.std.OptionInstances
+  with scalaz.std.OptionFunctions
+  with scalaz.std.StringInstances
+  with scalaz.syntax.std.ToOptionIdOps
+  with scalalib.OrnicarMonoid.Instances
+  with scalalib.Zero.Instances
+  with scalalib.OrnicarOption
+  with lila.LilaSteroids
   with StringHelper
   with JsonHelper
   with AssetHelper

modules/common/src/main/PackageObject.scala

@@ -1,14 +1,12 @@
 package lila
 
-import scala.concurrent.duration._
+import scala.concurrent.duration.{ Duration, FiniteDuration, MILLISECONDS }
 import scala.concurrent.Future
-import scala.util.Try
 
 import ornicar.scalalib
-
 import scalaz.{ Monad, Monoid, OptionT, ~> }
 
-trait PackageObject extends Lilaisms {
+trait PackageObject extends Steroids with WithFuture {
 
   // case object Key(value: String) extends AnyVal with StringValue
   trait StringValue extends Any {
@@ -39,14 +37,46 @@ trait PackageObject extends Lilaisms {
     def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x)
   }
 
-  def parseIntOption(str: String): Option[Int] =
-    Try(java.lang.Integer.parseInt(str)).toOption
+  implicit final class LilaPimpedString(s: String) {
+
+    def boot[A](v: => A): A = lila.common.Chronometer.syncEffect(v) { lap =>
+      lila.log.boot.info(s"${lap.millis}ms $s")
+    }
+  }
+
+  implicit final class LilaPimpedValid[A](v: Valid[A]) {
+
+    def future: Fu[A] = v fold (errs => fufail(errs.shows), fuccess)
+  }
 
-  def parseFloatOption(str: String): Option[Float] =
-    Try(java.lang.Float.parseFloat(str)).toOption
+  implicit final class LilaPimpedTry[A](v: scala.util.Try[A]) {
 
-  def parseLongOption(str: String): Option[Long] =
-    Try(java.lang.Long.parseLong(str)).toOption
+    def fold[B](fe: Exception => B, fa: A => B): B = v match {
+      case scala.util.Failure(e: Exception) => fe(e)
+      case scala.util.Failure(e) => throw e
+      case scala.util.Success(a) => fa(a)
+    }
+
+    def future: Fu[A] = fold(Future.failed, fuccess)
+  }
+
+  def parseIntOption(str: String): Option[Int] = try {
+    Some(java.lang.Integer.parseInt(str))
+  } catch {
+    case e: NumberFormatException => None
+  }
+
+  def parseFloatOption(str: String): Option[Float] = try {
+    Some(java.lang.Float.parseFloat(str))
+  } catch {
+    case e: NumberFormatException => None
+  }
+
+  def parseLongOption(str: String): Option[Long] = try {
+    Some(java.lang.Long.parseLong(str))
+  } catch {
+    case e: NumberFormatException => None
+  }
 
   def intBox(in: Range.Inclusive)(v: Int): Int =
     math.max(in.start, math.min(v, in.end))
@@ -58,13 +88,25 @@ trait PackageObject extends Lilaisms {
     math.max(in.start, math.min(v, in.end))
 }
 
+trait WithFuture extends scalalib.Validation {
+
+  type Fu[+A] = Future[A]
+  type Funit = Fu[Unit]
+
+  def fuccess[A](a: A) = Future successful a
+  def fufail[A <: Throwable, B](a: A): Fu[B] = Future failed a
+  def fufail[A](a: String): Fu[A] = fufail(common.LilaException(a))
+  def fufail[A](a: Failures): Fu[A] = fufail(common.LilaException(a))
+  val funit = fuccess(())
+}
+
 trait WithPlay { self: PackageObject =>
 
   import play.api.libs.json._
-  import ornicar.scalalib.Zero
+  import scalalib.Zero
 
   implicit def playExecutionContext = play.api.libs.concurrent.Execution.defaultContext
-  val directEC = lila.common.implicits.DirectExecutionContext
+  val directEC = lila.PimpedFuture.DirectExecutionContext
 
   implicit val LilaFutureMonad = new Monad[Fu] {
     override def map[A, B](fa: Fu[A])(f: A => B) = fa map f
@@ -92,11 +134,72 @@ trait WithPlay { self: PackageObject =>
       Future sequence t
   }
 
+  implicit def LilaPimpedFuture[A](fua: Fu[A]): PimpedFuture.LilaPimpedFuture[A] =
+    new PimpedFuture.LilaPimpedFuture(fua)
+
+  implicit final class LilaPimpedFutureZero[A: Zero](fua: Fu[A]) {
+
+    def nevermind: Fu[A] = fua recover {
+      case e: lila.common.LilaException => zero[A]
+      case e: java.util.concurrent.TimeoutException => zero[A]
+      case e: Exception =>
+        lila.log("common").warn("Future.nevermind", e)
+        zero[A]
+    }
+  }
+
+  implicit final class LilaPimpedFutureOption[A](fua: Fu[Option[A]]) {
+
+    def flatten(msg: => String): Fu[A] = fua flatMap {
+      _.fold[Fu[A]](fufail(msg))(fuccess(_))
+    }
+
+    def orElse(other: => Fu[Option[A]]): Fu[Option[A]] = fua flatMap {
+      _.fold(other) { x => fuccess(x.some) }
+    }
+
+    def getOrElse(other: => Fu[A]): Fu[A] = fua flatMap { _.fold(other)(fuccess) }
+  }
+
+  implicit final class LilaPimpedFutureValid[A](fua: Fu[Valid[A]]) {
+
+    def flatten: Fu[A] = fua flatMap { _.fold[Fu[A]](fufail(_), fuccess(_)) }
+  }
+
+  implicit final class LilaPimpedFutureBoolean(fua: Fu[Boolean]) {
+
+    def >>&(fub: => Fu[Boolean]): Fu[Boolean] =
+      fua flatMap { _.fold(fub, fuccess(false)) }
+
+    def >>|(fub: => Fu[Boolean]): Fu[Boolean] =
+      fua flatMap { _.fold(fuccess(true), fub) }
+
+    def unary_! = fua dmap (!_)
+  }
+
+  implicit final class LilaPimpedBooleanWithFuture(self: Boolean) {
+
+    def optionFu[A](v: => Fu[A]): Fu[Option[A]] = if (self) v map (_.some) else fuccess(none)
+  }
+
   implicit final class LilaPimpedActorSystem(self: akka.actor.ActorSystem) {
 
     def lilaBus = lila.common.Bus(self)
   }
 
+  implicit final class LilaPimpedFiniteDuration(self: FiniteDuration) {
+
+    def toCentis = chess.Centis {
+      // divide by Double, then round, to avoid rounding issues with just `/10`!
+      math.round {
+        if (self.unit eq MILLISECONDS) self.length / 10d
+        else self.toMillis / 10d
+      }
+    }
+
+    def abs = if (self.length < 0) -self else self
+  }
+
   implicit val LilaFiniteDurationZero: Zero[FiniteDuration] = Zero.instance(Duration.Zero)
 
   implicit val LilaCentisZero: Zero[chess.Centis] = Zero instance chess.Centis(0)

modules/common/src/main/PimpedConfig.scala

@@ -0,0 +1,16 @@
+package lila.common
+
+import scala.concurrent.duration._
+import java.util.concurrent.TimeUnit
+
+import com.typesafe.config.Config
+
+object PimpedConfig {
+
+  implicit final class LilaPimpedConfig(val config: Config) extends AnyVal {
+
+    def millis(name: String): Int = config.getDuration(name, TimeUnit.MILLISECONDS).toInt
+    def seconds(name: String): Int = config.getDuration(name, TimeUnit.SECONDS).toInt
+    def duration(name: String): FiniteDuration = millis(name).millis
+  }
+}