integration code between Scalaz and Scala standard concurrency libraries.

Task.scala

import concurrent.{ExecutionContext, Future => SFuture, Promise}                 
import util.Try                                                                                                 
                                                                                                                
import _root_.scalaz.\/                                                                                         
import _root_.scalaz.concurrent.{Task => ZTask}                                                                 
                                                                                                                
                                                                                                                
object Task {                                                                                                   
                                                                                                                
  def fromScala[A]                                                                                              
      (future: SFuture[A])(implicit ec: ExecutionContext): ZTask[A] =            
    ZTask async (handlerConversion andThen future.onComplete)                    
                                                                                                                
  def fromScalaDeferred[A]                                                                                      
      (future: => SFuture[A])(implicit ec: ExecutionContext): ZTask[A] =         
    ZTask delay fromScala(future)(ec) flatMap identity                           
                                                                                                                
  def unsafeToScala[A](task: ZTask[A]): SFuture[A] = {                           
    val p = Promise[A]                                                                                          
    task runAsync { _ fold (p failure _, p success _) }                          
    p.future                                                                                                    
  }                                                                                                             
                                                                                                                
  private def handlerConversion[A]                                                                              
      : ((Throwable \/ A) => Unit) => Try[A] => Unit =                           
    callback => { t: Try[A] => \/ fromTryCatch t.get } andThen callback          
                                                                                                                
}