Futuro che non può fallire in Scala

Question

Esiste il concetto di uno Future che non può fallire in Scala?

sto trasformando un Future[Result], che può fail-perciò gestire sia un Failure e Success -nel un Future[Option[String]], portando un messaggio di errore facoltativa derivante dalle fallimento o il successo stati. Fin qui tutto bene.

La cosa è ora, vorrei formalmente (vale a dire, con l'aiuto del sistema di tipi) ricordare che questo futuro avrà sempre un Success e che non avrò bisogno di gestire il caso di fallimento in futuro.

C'è un modo intelligente per farlo?

Answer 1

Non è questo il tipo di codifica?

scala> type Tagged[U] = { type Tag = U } 
defined type alias Tagged 

scala> type @@[T, U] = T with Tagged[U] 
defined type alias $at$at 

scala> trait OK ; trait Uncertain 
defined trait OK 
defined trait Uncertain 

scala> type Sure[A] = Future[A] @@ OK 
defined type alias Sure 

scala> type Unsure[A] = Future[A] @@ Uncertain 
defined type alias Unsure 

scala> val f = Future.successful(42).asInstanceOf[Sure[Int]] 
f: Sure[Int] = Future(Success(42)) 

poi

scala> object X { def p(f: Sure[_]) = "sure" ; def p(f: Unsure[_])(implicit d: DummyImplicit) = "unsure" } 
defined object X 

scala> X.p(f) 
res1: String = sure 

Non resta sicuro sotto la mappa, ovviamente.

Answer 2

Non è possibile farlo "con l'aiuto del sistema di tipi" perché non è possibile che il sistema di tipi garantisca un errore Future, anche se si promette che non lo farà.

Considerate questo:

Future { doStuff(); } 
    .recover { case _ => "Failed!" } // Now it always succeeds 
    .map { _ => Seq.empty[String].head } // Now it does not. 

Anche se si andavano a rendere impossibile ogni ulteriore trasformazione, una volta che il Future è stato dichiarato di riuscire sempre, che ancora non aiuta, perché il gestore di eccezioni (o quello che fare per convertire il futuro originale in "sempre successo") potrebbe gettare.

Aggiornamento: come ha sottolineato in un commento qui sotto, il frammento di codice di cui sopra non è corretto: il risultato di .map non è la stessa Future come il risultato di .recover. Il punto si regge comunque. Ecco l'illustrazione corretta:

Future { doStuff } 
    .recover { case _ => Seq.empty[String].head }