Scala Failure类代码示例

//设置package包名称以及导入依赖的类
package biz.meetmatch.decorators

import biz.meetmatch.logging.BusinessLogger
import org.apache.spark.sql.SparkSession
import org.rogach.scallop.Scallop

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

object WithCalcLogging {
  def apply[B](f: => B)(implicit module: Class[_]): B = apply(module.getName)(f)

  def apply[B](scallopts: Scallop, sparkSession: SparkSession)(f: => B)(implicit module: Class[_] = this.getClass): B = apply(module.getName, Some(scallopts), Some(sparkSession))(f)

  def apply[B](module: String)(f: => B): B = apply(module, None, None)(f)

  def apply[B](module: String, scallopts: Scallop)(f: => B)(): B = apply(module, Some(scallopts), None)(f)

  def apply[B](module: String, scallopts: Scallop, sparkSession: SparkSession)(f: => B): B = apply(module, Some(scallopts), Some(sparkSession))(f)

  def apply[B](module: String, scalloptsO: Option[Scallop], sparkSessionO: Option[SparkSession])(f: => B): B = {
    val businessLogger = new BusinessLogger(module)

    val optsString = scalloptsO
      .map { scallopts =>
        scallopts.opts
          .map { opt => opt.name + " = " + scallopts.get(opt.name)(opt.converter.tag).getOrElse("(empty)") }
          .mkString(",")
      }
      .getOrElse("")

    val sparkAppId = sparkSessionO.map(_.sparkContext.applicationId).getOrElse("")

    businessLogger.calcStarted(optsString, sparkAppId)
    val attempt = Try(WithStopwatch(f))

    attempt match {
      case Success(result) =>
        businessLogger.calcStopped("SUCCESS")
        result
      case Failure(exception) =>
        businessLogger.calcStopped("FAILURE")
        throw exception
    }
  }
} 

//设置package包名称以及导入依赖的类
package im.actor.server.activation.common

import akka.actor.ActorSystem
import im.actor.config.ActorConfig

import scala.collection.JavaConversions._
import scala.util.{ Failure, Success, Try }

object ActivationProviders {
  val Sms = "sms"
  val Smtp = "smtp"
  val Call = "call"
  val Internal = "internal"

  /**
   * Instantiates activation providers based on configuration.
   * Makes sure to instantiate only one instance of provider,
   * if it is present for several activation types
   * @param system actor system
   * @return map from activation type to activation provider instance
   */
  def getProviders()(implicit system: ActorSystem): Map[String, ActivationProvider] = {
    val providersConfig = ActorConfig.load().getConfig("services.activation.providers")
    val configMap = providersConfig.root.unwrapped.toMap

    val reverseAcc = Map.empty[String, List[String]].withDefaultValue(List.empty[String])
    // this is made to avoid duplicate instantiation of same providers
    val reverseMap = (configMap foldLeft reverseAcc) {
      case (acc, (activationType, value)) ?
        val className = value.toString
        acc.updated(className, activationType :: acc(className))
    }

    reverseMap flatMap {
      case (className, activationTypes) ?
        providerOf(className, system) match {
          case Success(instance) ?
            system.log.debug("Successfully instantiated code provider: {}, for activation types: [{}]", className, activationTypes mkString ", ")
            (activationTypes map { _ ? instance }).toMap
          case Failure(e) ?
            system.log.warning("Failed to instantiate code provider: {}, exception: {}", className, e)
            Map.empty[String, ActivationProvider]
        }
    }
  }

  private def providerOf(fqcn: String, system: ActorSystem): Try[ActivationProvider] = {
    for {
      constructor ? Try(Class.forName(fqcn).asSubclass(classOf[ActivationProvider]).getConstructor(classOf[ActorSystem]))
    } yield constructor.newInstance(system)
  }
} 

//设置package包名称以及导入依赖的类
package eu.svez.akka.stream

import akka.NotUsed
import akka.stream.FanOutShape2
import akka.stream.scaladsl.{Flow, GraphDSL, Partition}

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

object Stages {

  object PartitionEither {
    def apply[A, B]() = GraphDSL.create[FanOutShape2[Either[A, B], A, B]]() { implicit builder: GraphDSL.Builder[NotUsed] =>
      import GraphDSL.Implicits._

      val left = builder.add(Flow[Either[A, B]].map (_.left.get))
      val right = builder.add(Flow[Either[A, B]].map (_.right.get))
      val partition = builder.add(Partition[Either[A, B]](2, _.fold(_ ? 0, _ ? 1)))

      partition ~> left
      partition ~> right

      new FanOutShape2[Either[A, B], A, B](partition.in, left.out, right.out)
    }
  }

  implicit class EitherShape[A, B](val shape: FanOutShape2[Either[A, B], A, B]) extends AnyVal {
    def left = shape.out0
    def right = shape.out1
  }

  object PartitionTry {
    def apply[T]() = GraphDSL.create[FanOutShape2[Try[T], Throwable, T]]() { implicit builder ?
      import GraphDSL.Implicits._

      val success = builder.add(Flow[Try[T]].collect { case Success(a) ? a })
      val failure = builder.add(Flow[Try[T]].collect { case Failure(t) ? t })
      val partition = builder.add(Partition[Try[T]](2, _.map(_ ? 1).getOrElse(0)))

      partition ~> failure
      partition ~> success

      new FanOutShape2[Try[T], Throwable, T](partition.in, failure.out, success.out)
    }
  }

  implicit class TryShape[T](val shape: FanOutShape2[Try[T], Throwable, T]) extends AnyVal {
    def failure = shape.out0
    def success = shape.out1
  }

} 

//设置package包名称以及导入依赖的类
package com.flipkart.connekt.commons.services

import com.flipkart.concord.publisher.{RequestType, TPublishRequest, TPublishRequestMetadata, TPublisher}
import com.flipkart.connekt.commons.factories.{ConnektLogger, LogFile}
import com.flipkart.connekt.commons.metrics.Instrumented
import com.flipkart.connekt.commons.utils._
import com.flipkart.metrics.Timed

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

object BigfootService extends Instrumented {

  private lazy val phantomSocketPath: String = ConnektConfig.getString("connections.specter.socket").get
  private lazy val ingestionEnabled = ConnektConfig.getBoolean("flags.bf.enabled").getOrElse(false)
  private lazy val jUnixSocketLibPath = ConnektConfig.getString("connections.specter.lib.path").get

  lazy val phantomPublisher: TPublisher[String] = {
    if(ingestionEnabled) {
      try {
        val configLoaderClass = Class.forName("com.flipkart.connekt.util.publisher.PhantomSocketPublisher")
        configLoaderClass.getConstructor(classOf[String], classOf[String], classOf[String]).newInstance(jUnixSocketLibPath, phantomSocketPath, "publishToBigFoot").asInstanceOf[TPublisher[String]]
      } catch {
        case e: Exception =>
          ConnektLogger(LogFile.SERVICE).error("Unable to initialize PhantomPublisher", e)
          null
      }
    } else null
  }

  private def ingest(request: TPublishRequest, requestMetadata: TPublishRequestMetadata): Try[Boolean] = Try {
    if(ingestionEnabled) {
      phantomPublisher.publish(request, requestMetadata).response match {
        case Success(m) if m.equalsIgnoreCase("SUCCESS") => Success(true)
        case Success(m) =>
          ConnektLogger(LogFile.SERVICE).error(s"Phantom ingestion failed. CommandResponse: $m")
          Failure(new Throwable(s"Phantom ingestion failed. CommandResponse: $m"))
        case Failure(t) => Failure(t)
      }
    } else {
      Success(true)
    }
  }.flatten

  @Timed("ingestEntity")
  def ingestEntity(entityId: String, request: TPublishRequest, entityNamespace: String) = ingest(request, new TPublishRequestMetadata {
    override def requestType: RequestType.Value = RequestType.Entity

    override def id: String = entityId

    override def namespace(): Option[String] = Some(entityNamespace)
  })

  @Timed("ingestEvent")
  def ingestEvent(request: TPublishRequest, eventNamespace: String) = ingest(request, new TPublishRequestMetadata {
    override def requestType: RequestType.Value = RequestType.Event

    override def id: String = StringUtils.generateRandomStr(25)

    override def namespace(): Option[String] = Some(eventNamespace)
  })
} 

//设置package包名称以及导入依赖的类
package controllers

import javax.inject.Inject

import play.api.Logger
import play.api.libs.ws._
import play.api.mvc._
import services.ProxyRequestCreator.mapToForwardingRequest
import services.ResultTransformer.transformResult
import services.{DocsterDB, ServerBaseUriNotConfigured, ServerGateway}

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

class ProxyController @Inject()(ws: WSClient)(configStore: DocsterDB, serverGateway: ServerGateway) extends Controller {

  implicit val context = play.api.libs.concurrent.Execution.Implicits.defaultContext

  def proxy(requestPath: String) = Action.async(parse.tolerantText) { originalRequest =>
    val result: Try[Future[Result]] = for {
      forwardingRequest <- mapToForwardingRequest(originalRequest, requestPath, configStore)
      serverResponse <- Try(serverGateway.forwardRequestToServer(forwardingRequest, ws))
      transformedResult <- Try(transformResult(serverResponse, forwardingRequest))
    } yield transformedResult

    result match {
      case Failure(ex) =>
        ex match {
          case ex: ServerBaseUriNotConfigured =>
            Future.successful(Redirect(controllers.routes.AdminController.adminConsole()))
          case default =>
            Logger.error(ex.getMessage, ex)
            Future(InternalServerError(ex.getMessage))
        }
      case Success(finalResult) => finalResult
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.ferhtaydn.models

import java.io.File

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

case class CancerRecord(label: Double, gender: Double, age: Double, weight: Double, height: Double, job: String)

object CancerRecord {

  private val commaRegex: String = "\\,"

  def from(s: String): Option[CancerRecord] = s.split(commaRegex) match {
    case Array(result, gender, age, weight, height, job) ?
      Some(CancerRecord(result.toDouble, Gender.id(gender).toDouble, age.toDouble, weight.toDouble, height.toDouble, job))
    case _ ? None
  }

  def read(file: String): Seq[CancerRecord] = Try(scala.io.Source.fromFile(file)) match {
    case Success(bufferedSource) ?
      for {
        a ? bufferedSource.getLines().toSeq.map(CancerRecord.from)
        b ? a
      } yield b
    case Failure(exception) ? Seq.empty[CancerRecord]
  }

} 

//设置package包名称以及导入依赖的类
package akka.stream

import akka.stream.testkit.AkkaSpec
import akka.stream.testkit.ScriptedTest
import scala.concurrent.forkjoin.ThreadLocalRandom.{ current ? random }
import akka.stream.testkit.StreamTestKit
import scala.concurrent.Await
import scala.concurrent.duration._
import scala.util.Failure
import akka.stream.scaladsl.Flow

class FlowToFutureSpec extends AkkaSpec with ScriptedTest {

  val materializer = FlowMaterializer(MaterializerSettings(
    initialInputBufferSize = 2,
    maximumInputBufferSize = 16,
    initialFanOutBufferSize = 1,
    maxFanOutBufferSize = 16))

  "A Flow with toFuture" must {

    "yield the first value" in {
      val p = StreamTestKit.producerProbe[Int]
      val f = Flow(p).toFuture(materializer)
      val proc = p.expectSubscription
      proc.expectRequestMore()
      proc.sendNext(42)
      Await.result(f, 100.millis) should be(42)
      proc.expectCancellation()
    }

    "yield the first error" in {
      val p = StreamTestKit.producerProbe[Int]
      val f = Flow(p).toFuture(materializer)
      val proc = p.expectSubscription
      proc.expectRequestMore()
      val ex = new RuntimeException("ex")
      proc.sendError(ex)
      Await.ready(f, 100.millis)
      f.value.get should be(Failure(ex))
    }

    "yield NoSuchElementExcption for empty stream" in {
      val p = StreamTestKit.producerProbe[Int]
      val f = Flow(p).toFuture(materializer)
      val proc = p.expectSubscription
      proc.expectRequestMore()
      proc.sendComplete()
      Await.ready(f, 100.millis)
      f.value.get match {
        case Failure(e: NoSuchElementException) ? e.getMessage() should be("empty stream")
        case x                                  ? fail("expected NoSuchElementException, got " + x)
      }
    }

  }

} 

//设置package包名称以及导入依赖的类
package controllers

import java.io.File

import play.api.http.ContentTypes
import play.api.mvc.{Action, Controller}
import service.InventoryLogService
import util.JsonUtil

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

object InventoryLogController extends Controller {

  def create = Action {
    InventoryLogService.createSchema
    Ok("Schema Created")
  }

  def truncate = Action {
    InventoryLogService.truncateData
    Ok("Schema Truncated")
  }

  def upload = Action(parse.multipartFormData) { implicit request =>
    val files = request.body.files
    Try(files.map { file =>
      val tmpFile = file.ref.moveTo(new File(s"/tmp/${file.filename}"))
      InventoryLogService.populateSchema(tmpFile)
      tmpFile.delete
    }) match {
      case Success(_) => if(files.size <= 0) BadRequest("File Not uploaded!!") else Ok("File Uploaded")
      case Failure(x) => BadRequest(s"Upload Error!! ${x.getMessage}")
    }
  }

  def track = Action { request =>
    val trackRequest = request.body.asJson
    Try(trackRequest.map { json =>
      val objectId = (json \ "object_id").as[Int]
      val objectType = (json \ "object_type").as[String]
      val timestamp = (json \ "timestamp").as[Long]
      InventoryLogService.trackStatus(objectId, objectType, timestamp)
    }.getOrElse {
      BadRequest("Expecting application/json request body")
    }) match {
      case Success(x: Some[Any]) => Ok(JsonUtil.toJson(x.getOrElse(Map.empty))).as(ContentTypes.JSON)
      case Success(_) => Ok("No updates available")
      case Failure(_) => BadRequest("Expecting all input parameters")
    }
  }

  def details = Action {
    Ok(JsonUtil.toJson(InventoryLogService.trackDetails)).as(ContentTypes.JSON)
  }


} 

//设置package包名称以及导入依赖的类
package com.lookout.ratelimitingfilter

import scala.util.{Success, Failure, Try}
import com.twitter.logging.Logger
import com.lookout.ratelimitingfilter.models._
import com.redis._

object LeakyBucket {
  val LOG = Logger.get(getClass)

  
  def processRule(rule: RateLimitRule, leakAndIncFn: (RateLimitRule) => Try[Int]): Boolean = {
    leakAndIncFn(rule) match {
      case Success(tokenCount) => {
        if (tokenCount < rule.threshold) {
          true
        } else {
          LOG.info(s"Request is rate limited with rule id: ${rule.id} and threshold: ${rule.threshold}")
          false
        }
      }
      case Failure(error) => throw error
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.goingok.httpServer

import akka.http.scaladsl.Http
import org.goingok.BuildInfo
import org.goingok.data.persistence.db.DatabaseOps

import scala.util.{Failure, Success}




object Server extends GoingOkAPI {
  import org.goingok.GoingOkContext._

  var dbOk = false

  def startServer(address:String, port:Int) = {
    log.info("->> STARTING {} - version {} <<-",BuildInfo.name,BuildInfo.version)
    log.info("Connecting to DB server")
    connectDb
    log.info("Starting http server at {}:{}",address,port)
    Http().bindAndHandle(routes,address,port)
  }

  def connectDb: Unit = {
    DatabaseOps.version.onComplete {
      case Success(result:String) => {
        dbOk = true
        log.info("Current version is: "+result)
        // Create tables that don't exist
        DatabaseOps.checkAndCreateTables()
        // Get the number of rows for all tables
        val tableRows = DatabaseOps.tableSizes()
        if(tableRows.isLeft) tableRows.left.map(i => log.info("Database tables exist: {}",i))
        else log.error("There was a problem with accessing the database tables")
      }
      case Failure(e:Exception) => log.error("Could not get version from db: "+e.getMessage)
      case _ => log.error("There was a problem getting the version from the database")
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.dele.text.lapa.patterns

import org.dele.text.lapa.ErrorHandling.{MatcherGenErrorFailed, MatcherGenErrorUndefinedTemplate}
import DomainStructure.LangDomainManager
import org.dele.text.maen.ConfValueStringParser.Parsed
import org.dele.text.maen.matchers.MatcherTmpl.{DomainIdFinder, MatcherTmplLib}
import org.dele.text.maen.matchers.SubMatchCheckerLib._
import org.dele.text.maen.matchers.{MatcherTmpl, MatcherManager, SubMatchCheckerLib, TMatcher}
import org.dele.text.maen.{ConfValueStringParser, AtomPropMatcherLib}
import org.dele.text.maen.matchers.TMatcher.MId

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


trait TMatcherGen {
  def spawn(parsedDefi: Parsed, id:Option[MId], regexDict:Map[String,String])(implicit domainManager:LangDomainManager, subMatchCheckerLib: SubMatchCheckerLib, domain:Option[String]):Try[TMatcher]
}

object TMatcherGen {

  private[TMatcherGen] class AtomLibMatcherGen extends TMatcherGen {
    import TMatcher._
    def spawn(parsedDefi: Parsed, id:Option[MId], regexDict:Map[String,String])(implicit domainManager:LangDomainManager, subMatchCheckerLib: SubMatchCheckerLib, domain:Option[String]):Try[TMatcher] = {
      //val parsed = ConfValueStringParser.parse(defi)
      if (AtomPropMatcherLib.contains(parsedDefi.id)) Success(fromAtomMatcher(AtomPropMatcherLib.spawn(parsedDefi.id, parsedDefi.paras, regexDict), EmptyCheckerIds, id))
      else Failure(MatcherGenErrorUndefinedTemplate(parsedDefi.id))
    }
  }

  val NoMatcherTemplateLibGen:TMatcherGen = new AtomLibMatcherGen

  private[TMatcherGen] class MatcherTemplateGen(val tmplLib:MatcherTmplLib) extends TMatcherGen {
    def spawn(parsedDefi: Parsed, id:Option[MId], regexDict:Map[String,String])(implicit domainManager:LangDomainManager, subMatchCheckerLib: SubMatchCheckerLib, domain:Option[String]):Try[TMatcher] = {
      if (tmplLib.contains(parsedDefi.id)) {
        val domainIdFinder:DomainIdFinder = id => if (domain.nonEmpty) domainManager.getFullId(domain.get, id) else domainManager.getGlobalDomainFullId(id)
        Success(tmplLib.spawn(parsedDefi.id, parsedDefi.paras, regexDict, id, Option(domainIdFinder)))
      }
      else Failure(MatcherGenErrorUndefinedTemplate(parsedDefi.id))
    }
  }

  private[TMatcherGen] class ChainedGen(val matcherGens:TMatcherGen*) extends TMatcherGen {
    def spawn(parsedDefi: Parsed, id:Option[MId], regexDict:Map[String,String])(implicit domainManager:LangDomainManager, subMatchCheckerLib: SubMatchCheckerLib, domain:Option[String]):Try[TMatcher] = {
      val gened = matcherGens.map(_.spawn(parsedDefi, id, regexDict))
      val filtered = gened.filter(_.isSuccess)
      if (filtered.nonEmpty) filtered(0)
      else Failure(MatcherGenErrorFailed(parsedDefi))
    }
  }

  private def TemplateGen(tmplLib:MatcherTmplLib)(implicit subMatchCheckerLib: SubMatchCheckerLib):TMatcherGen = {
    new MatcherTemplateGen(tmplLib)
  }

  def All(tmplLib:MatcherTmplLib)(implicit subMatchCheckerLib: SubMatchCheckerLib):TMatcherGen =
    new ChainedGen(TemplateGen(tmplLib), NoMatcherTemplateLibGen)
} 

//设置package包名称以及导入依赖的类
package com.scalaio.http.monitoring

import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model.ContentTypes._
import akka.http.scaladsl.model.{HttpEntity, HttpResponse, StatusCodes, Uri}
import akka.http.scaladsl.model.StatusCodes._
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server._
import akka.stream.Materializer
import com.typesafe.config.Config
import com.yammer.metrics.HealthChecks
import com.yammer.metrics.core.HealthCheckRegistry
import org.slf4j.LoggerFactory
import play.api.libs.json.{JsArray, Json}

import scala.util.{Failure, Success}
import scala.collection.convert.wrapAsScala._

object MonitoringServer {

  lazy val logger = LoggerFactory.getLogger(getClass)

  def handleHealthchecks(registry: HealthCheckRegistry): Route = {
    path("health") {
      get {
        complete {
          val checks = registry.runHealthChecks
          val payload = JsArray(checks.map {
            case (name, result) =>
              Json.obj(
                "name" -> name,
                "healthy" -> result.isHealthy,
                "message" -> result.getMessage
              )
          }.toSeq)
          val status = if (checks.values().forall(_.isHealthy)) OK else InternalServerError
          HttpResponse(entity = HttpEntity(`application/json`, Json.stringify(payload)), status = status)
        }
      }
    }
  }

  def start(serverConfig: Config, registry: HealthCheckRegistry = HealthChecks.defaultRegistry())
           (implicit system: ActorSystem, materializer: Materializer): Unit = {
    val host = serverConfig.getString("host")
    val port = serverConfig.getInt("port")
    logger.info(s"Starting monitoring server at: $host:$port")

    val routes = handleHealthchecks(registry) ~ redirect(Uri("/health"), StatusCodes.SeeOther)
    import system.dispatcher
    Http()
      .bindAndHandle(routes, host, port).onComplete {
      case Success(Http.ServerBinding(address)) =>
        logger.info(s"Monitoring server started at :$address")
      case Failure(t) =>
        logger.error("Error while trying to start monitoring server", t)
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.bob.scalatour.futures

import org.scalatest.FunSuite

import scala.async.Async._

import scala.concurrent.ExecutionContext
import scala.util.{Failure, Success}

class AsyncTest extends FunSuite {

  implicit val ec = ExecutionContext.global

  test("sequential") {
    val future = async {
      val futureOne = async {
        1
      }
      val futureTwo = async {
        2
      }
      await(futureOne) + await(futureTwo)
    }
    future onComplete {
      case Success(result) => assert(result == 3)
      case Failure(failure) => throw failure
    }
  }

  test("parallel") {
    val futureOne = async {
      1
    }
    val futureTwo = async {
      2
    }
    val futureThree = async {
      await(futureOne) + await(futureTwo)
    }
    futureThree onComplete {
      case Success(result) => assert(result == 3)
      case Failure(failure) => throw failure
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.blinkmob

import java.sql.Connection
import javax.sql.DataSource

import resource._

import scala.util.control.ControlThrowable
import scala.util.{Failure, Success, Try}



trait CxProvider{ this:hasDataSource =>

  def cx[A](block: Connection => A): A = managed(ds.getConnection()).acquireAndGet(block(_))

  def tx[A](block: Connection => A): A ={
    cx { c =>
      c.setAutoCommit(false)
      Try({
        val r = block(c)
        c.commit()
        r
      }) match{
        case Success(r) => r
        case Failure(f) => {
          f match{
            case e: ControlThrowable => c.commit(); throw e
            case e => c.rollback(); throw e
          }
        }
      }


    }
  }

  def rbtx[A](block: Connection => A): A ={
    cx { c =>
      c.setAutoCommit(false)
      Try(block(c)) match{
        case Success(r) => c.rollback(); r
        case Failure(f) => c.rollback(); throw f
      }
    }
  }

} 

//设置package包名称以及导入依赖的类
package akka.pattern

import language.implicitConversions
import scala.concurrent.{ Future, ExecutionContext }
import scala.util.{ Failure, Success }
import akka.actor.{ Status, ActorRef, Actor }
import akka.actor.ActorSelection

trait PipeToSupport {

  final class PipeableFuture[T](val future: Future[T])(implicit executionContext: ExecutionContext) {
    def pipeTo(recipient: ActorRef)(implicit sender: ActorRef = Actor.noSender): Future[T] = {
      future onComplete {
        case Success(r) ? recipient ! r
        case Failure(f) ? recipient ! Status.Failure(f)
      }
      future
    }
    def pipeToSelection(recipient: ActorSelection)(implicit sender: ActorRef = Actor.noSender): Future[T] = {
      future onComplete {
        case Success(r) ? recipient ! r
        case Failure(f) ? recipient ! Status.Failure(f)
      }
      future
    }
    def to(recipient: ActorRef): PipeableFuture[T] = to(recipient, Actor.noSender)
    def to(recipient: ActorRef, sender: ActorRef): PipeableFuture[T] = {
      pipeTo(recipient)(sender)
      this
    }
    def to(recipient: ActorSelection): PipeableFuture[T] = to(recipient, Actor.noSender)
    def to(recipient: ActorSelection, sender: ActorRef): PipeableFuture[T] = {
      pipeToSelection(recipient)(sender)
      this
    }
  }

  
  implicit def pipe[T](future: Future[T])(implicit executionContext: ExecutionContext): PipeableFuture[T] = new PipeableFuture(future)
}