more future extensions

build.sbt

@@ -2,7 +2,7 @@ inThisBuild(
   Seq(
     scalaVersion       := "3.4.1",
     versionScheme      := Some("early-semver"),
-    version            := "11.1.1",
+    version            := "11.1.2",
     organization       := "org.lichess",
     licenses += ("MIT" -> url("https://opensource.org/licenses/MIT")),
     publishTo          := Option(Resolver.file("file", new File(sys.props.getOrElse("publishTo", ""))))

lila/src/main/scala/actor/AskPipeline.scala

@@ -7,7 +7,7 @@ import com.github.blemale.scaffeine.LoadingCache
 import java.util.concurrent.Executor
 
 import scalalib.future.FutureAfter
-import scalalib.future.FutureExtension.*
+import scalalib.future.extensions.*
 import scalalib.cache.scaffeine
 
 /*

lila/src/main/scala/actor/AsyncActorConcMap.scala

@@ -7,7 +7,7 @@ import java.util.concurrent.ConcurrentHashMap
 import java.util.function.Function
 import scala.jdk.CollectionConverters.*
 import scalalib.extensions.*
-import scalalib.future.FutureExtension.*
+import scalalib.future.extensions.*
 
 trait TellMap[Id]:
   def tell(id: Id, msg: Matchable): Unit

lila/src/main/scala/actor/AsyncActorSequencer.scala

@@ -7,7 +7,7 @@ import scala.concurrent.{ ExecutionContext, Future, Promise }
 
 import scalalib.model.Max
 import scalalib.future.FutureAfter
-import scalalib.future.FutureExtension.*
+import scalalib.future.extensions.*
 import java.util.concurrent.Executor
 
 final class AsyncActorSequencer(

lila/src/main/scala/future.scala

@@ -7,6 +7,7 @@ import scala.concurrent.ExecutionContext as EC
 import scala.util.control.NoStackTrace
 import scala.util.Try
 import alleycats.Zero
+import scalalib.extensions.so
 
 /** Returns a [[scala.concurrent.Future]] that will be completed with the success or failure of the provided
   * value after the specified duration. Implementation can be done with or without akka/pekko
@@ -15,7 +16,11 @@ type FutureAfter = [T] => (FiniteDuration) => (() => Future[T]) => Future[T]
 
 final class TimeoutException(msg: String) extends Exception(msg) with NoStackTrace
 
-object FutureExtension:
+given [A](using az: Zero[A]): Zero[Future[A]] with
+  def zero = Future.successful(az.zero)
+
+object extensions:
+
   extension [A](fua: Future[A])
 
     inline def dmap[B](f: A => B): Future[B]   = fua.map(f)(EC.parasitic)
@@ -92,3 +97,32 @@ object FutureExtension:
           after(duration)(() => Future(default))
         )
       )
+
+  extension [A](fua: Future[Option[A]])
+
+    def orFail(msg: => String)(using EC): Future[A] =
+      fua.flatMap:
+        _.fold[Future[A]](Future.failed(new Exception(msg)))(Future.successful)
+
+    def orFailWith(err: => Exception)(using EC): Future[A] =
+      fua.flatMap:
+        _.fold[Future[A]](Future.failed(err))(Future.successful)
+
+    def orElse(other: => Future[Option[A]])(using EC): Future[Option[A]] =
+      fua.flatMap:
+        _.fold(other): x =>
+          Future.successful(Some(x))
+
+    def getOrElse(other: => Future[A])(using EC): Future[A] = fua.flatMap { _.fold(other)(Future.successful) }
+    def orZeroFu(using z: Zero[A]): Future[A]               = fua.map(_.getOrElse(z.zero))(EC.parasitic)
+
+    def map2[B](f: A => B)(using EC): Future[Option[B]] = fua.map(_.map(f))
+    def dmap2[B](f: A => B): Future[Option[B]]          = fua.map(_.map(f))(EC.parasitic)
+
+    def getIfPresent: Option[A] =
+      fua.value match
+        case Some(scala.util.Success(v)) => v
+        case _                           => None
+
+    def mapz[B: Zero](fb: A => B)(using EC): Future[B]                    = fua.map { _.so(fb) }
+    infix def flatMapz[B: Zero](fub: A => Future[B])(using EC): Future[B] = fua.flatMap { _.so(fub) }

lila/src/main/scala/paginator.scala

@@ -7,7 +7,7 @@ import scala.concurrent.Future
 import scala.concurrent.ExecutionContext
 
 import scalalib.model.MaxPerPage
-import scalalib.future.FutureExtension.dmap
+import scalalib.future.extensions.dmap
 import scalalib.extensions.squeeze
 
 final class Paginator[A] private[paginator] (