2013-06-03 17 views
12

scala'nın Geleceği (2.10) 'un yeni scalaz7 geleceğine nasıl düzgün bir şekilde dönüştürülebileceği konusunda hiç kimseye bir kod gelmedi mi? Ben scala Geleceğe scala Promise üzeri scalaz geleceği dönüştürmek için sıcak biliyorum ama ÖrneğinScala 2.10'ın gelecekteki scalaz.concurrent.Future // Görevine Dönüştürme

etrafında düzgün bunu nasıl emin değilim

import scalaz.concurrent.{Future => Zuture} 
import scala.concurrent.Future 
Ben Sonra

implicit def scalaF2scalazF[A](in:Future[A]):Zuture[A]=??? 

uygulanmasını istiyorum

şu çünkü besbelli oyuncağı

implicit def scalaF2scalazTask[A](in:Future[A]):Task[A]=??? 

yazmaya ne olacağını gerçekten wa nt :-)

+0

sen [scalaz-Contrib] (https://github.com/typelevel/scalaz-contrib) kütüphane izlediniz mi toTask ve toFuture yöntemleri uygun ekler https://github.com/Verizon/delorean kullanabilir? Orada scala.concurrent.Future için [bazı örnekler] vardır (https://github.com/typelevel/scalaz-contrib/blob/master/scala210/main/scala/Future.scala). – folone

+0

İşaretlediğiniz için teşekkürler. Ancak anladım ki, scala futures'ı scalaz Monad/monoids/semigroup'a çevirmek. Bunun, Tasks/scalaz.Future işlevini kullanan bir kod parçasında nasıl kullanılabileceğinden emin değilsiniz. Küçük bir kod örneği önerebilir misiniz, kodun Tasco'yu (yani, scalaz-stream) kodlarını, scala'nın geleceğini (yani, oynatma yinelemelerini) kullanan biriyle kodladığınız yere nasıl bağlayabilirsiniz? –

cevap

21

Birkaç alternatifi değerlendirdikten sonra, aşağıdaki çözüme geldim. Açıkça, birisi scalaz.Monad[scala.concurrent.Future], scalaz.std.scalaFuturehttps://github.com/scalaz/scalaz/blob/series/7.2.x/core/src/main/scala/scalaz/std/Future.scala#L85 yolunu gitmek istiyorsa.

object ScalaFutureConverters { 


    implicit def scalaFuture2scalazTask[T](fut: Future[T])(implicit ec: ExecutionContext): Task[T] = { 
    Task.async { 
     register => 
     fut.onComplete { 
      case Success(v) => register(v.right) 
      case Failure(ex) => register(ex.left) 
     } 
    } 
    } 


    implicit def scalazTask2scalaFuture[T](task: Task[T]): Future[T] = { 
    val p: Promise[T] = Promise() 

    task.runAsync { 
     case -\/(ex) => p.failure(ex) 
     case \/-(r) => p.success(r) 
    } 

    p.future 
    } 


    implicit class ScalazFutureEnhancer[T](task: Task[T]) { 
    def asScala: Future[T] = scalazTask2scalaFuture(task) 
    } 


    implicit def scalaF2EnhancedScalaF[T](fut: Future[T])(implicit ec: ExecutionContext): ScalaFEnhancer[T] = 
    ScalaFEnhancer(fut)(ec) 

    case class ScalaFEnhancer[T](fut: Future[T])(implicit ec: ExecutionContext) { 
    def asTask: Task[T] = scalaFuture2scalazTask(fut)(ec) 
    } 

} 

Bu çözüm ancak aynı zamanda/duruma göre, istenen olabilir veya olmayabilir scala geleceğe dönüşüm yapıldıktan sonra görevi çalıştırır.

+4

Cevabın başlangıcındaki link şimdi kesildi. Yanıtın başında – jedesah

+0

sabit bağlantı – drstevens

0

Ayrıca

İlgili konular