2013-06-03 16 views
12

क्या कोई भी कोड के टुकड़े पर आया है कि कैसे स्केल के भविष्य (2.10) को नए स्केलज़ 7 भविष्य में सही ढंग से परिवर्तित किया जाए? मैं स्केला भविष्य के लिए स्केला वादा के माध्यम से scalaz भविष्य कन्वर्ट करने के लिए गर्म है, लेकिन कैसेस्कैला 2.10 भविष्य को scalaz.concurrent में बदलें। भविष्य // कार्य

चारों ओर ठीक से यह करने के लिए उदाहरण के लिए यकीन नहीं

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

मैं फिर

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

के कार्यान्वयन करना चाहते हैं स्पष्ट रूप से

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

लिखने के लिए केक का टुकड़ा होगा क्योंकि यही वह है जो मैं वास्तव में वा nt :-)

+0

आप [scalaz-योगदान] (https://github.com/typelevel/scalaz-contrib) पुस्तकालय देखा कहते हैं का उपयोग कर सकते हैं? 'Scala.concurrent.Future' के लिए [कुछ उदाहरण] (https://github.com/typelevel/scalaz-contrib/blob/master/scala210/main/scala/Future.scala) हैं। – folone

+0

इंगित करने के लिए धन्यवाद। हालांकि मुझे समझ में आया कि स्काला फ्यूचर्स को स्नालाज़ मोनाड/मोनोइड्स/सेमिग्रुप में परिवर्तित करना है। यह सुनिश्चित नहीं है कि इसका उपयोग कोड के टुकड़े में कैसे किया जा सकता है जो कार्य/स्केलज़ का उपयोग करता है। भविष्य। क्या आप कोड के छोटे उदाहरण का सुझाव दे सकते हैं कि आप उस कोड को कैसे लिंक करेंगे जहां आपने स्कैक के भविष्य का उपयोग करने वाले किसी के साथ कार्य (यानी स्केलज़-स्ट्रीम) हार्डकोड किया है (यानी इसे चलाने के लिए)? –

उत्तर

21

कुछ विकल्पों का मूल्यांकन करने के बाद मैं समाधान का पालन करने आया हूं। जाहिर है अगर कोई 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 जाने का तरीका है।

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) 
    } 

} 

यह समाधान हालात के आधार पर स्केल भविष्य में रूपांतरण के बाद भी वांछित हो सकता है, जो स्थिति के आधार पर वांछित हो सकता है।

+4

उत्तर की शुरुआत में लिंक अब टूटा हुआ है। उत्तर की शुरुआत में – jedesah

+0

निश्चित लिंक – drstevens

संबंधित मुद्दे