斯卡拉：「使用」功能

Question

我定義「使用」功能如下：

def using[A, B <: {def close(): Unit}] (closeable: B) (f: B => A): A = 
    try { f(closeable) } finally { closeable.close() } 

我可以用它這樣的：

using(new PrintWriter("sample.txt")){ out => 
    out.println("hellow world!") 
} 

現在我很好奇如何定義「使用'功能採取任意數量的參數，並能夠分別訪問它們：

using(new BufferedReader(new FileReader("in.txt")), new PrintWriter("out.txt")){ (in, out) => 
    out.println(in.readLIne) 
} 

Answer 1

不幸的是，不支持任意長度的pa rameter使用標準Scala中的任意類型列表。

您可能可以通過一些語言更改來做類似的事情（以便將可變參數列表作爲HList傳遞;請參閱here約需要的1/3）。

現在，最好的辦法就是做元組和函數做的事情：用N來實現儘可能多的N。

二是很容易的，當然：

def using2[A, B <: {def close(): Unit}, C <: { def close(): Unit}](closeB: B, closeC: C)(f: (B,C) => A): A = { 
    try { f(closeB,closeC) } finally { closeB.close(); closeC.close() } 
} 

如果你需要更多的，它可能是值得寫的東西，會生成源代碼。

Answer 2

我一直在想這個，我想可能是有另一種方式來解決這個問題。下面是我對支持的參數「任意數量」（由什麼元組提供有限）：

object UsingTest { 

    type Closeable = {def close():Unit } 

    final class CloseAfter[A<:Product](val x: A) { 
    def closeAfter[B](block: A=>B): B = { 
     try { 
     block(x); 
     } finally { 
     for (i <- 0 until x.productArity) { 
      x.productElement(i) match { 
      case c:Closeable => println("closing " + c); c.close() 
      case _ => 
      } 
     } 
     } 
    } 
    } 

    implicit def any2CloseAfter[A<:Product](x: A): CloseAfter[A] = 
    new CloseAfter(x) 

    def main(args:Array[String]): Unit = { 
    import java.io._ 

    (new BufferedReader(new FileReader("in.txt")), 
    new PrintWriter("out.txt"), 
    new PrintWriter("sample.txt")) closeAfter {case (in, out, other) => 
     out.println(in.readLine) 
     other.println("hello world!") 
    } 
    } 
} 

我想我重複使用22元組/產品類別已經寫在庫中的事實......我不認爲這個語法比使用嵌套using（沒有雙關意圖）更清晰，但它是一個有趣的謎題。

edit：按照retronym的建議，用case (in, out, other)替換val賦值。

Answer 3

這裏是一個例子，它允許你使用scala作爲自動資源管理塊來理解任何java.io.Closeable的項目，但是它可以很容易地擴展爲適用於任何接近方法。

該用法看起來非常接近using語句，並允許您輕鬆地在一個塊中定義儘可能多的資源。

object ResourceTest{ 
    import CloseableResource._ 
    import java.io._ 

    def test(){ 
    for(input <- new BufferedReader(new FileReader("/tmp/input.txt")); output <- new FileWriter("/tmp/output.txt")){ 
     output.write(input.readLine) 
    } 
    } 
} 

class CloseableResource[T](resource: =>T,onClose: T=>Unit){ 
    def foreach(f: T=>Unit){ 
    val r = resource 
    try{ 
     f(r) 
    } 
    finally{ 
     try{ 
     onClose(r) 
     } 
     catch{ 
     case e => 
      println("error closing resource") 
      e.printStackTrace 
     } 
    } 
    } 
} 

object CloseableResource{ 
    implicit def javaCloseableToCloseableResource[T <: java.io.Closeable](resource:T):CloseableResource[T] = new CloseableResource[T](resource,{_.close}) 
} 

Answer 4

有人已經做到了這一點—這就是所謂的Scala ARM。

自述：

import resource._ 
for(input <- managed(new FileInputStream("test.txt")) { 
    // Code that uses the input as a FileInputStream 
} 

Answer 5

這種解決方案並不相當有你想要的語法，但我認爲這是足夠接近:)

def using[A <: {def close(): Unit}, B](resources: List[A])(f: List[A] => B): B = 
    try f(resources) finally resources.foreach(_.close()) 

using(List(new BufferedReader(new FileReader("in.txt")), new PrintWriter("out.txt"))) { 
    case List(in: BufferedReader, out: PrintWriter) => out.println(in.readLine()) 
} 

當然不好的一面是您必須在使用塊中輸入BufferedReader和PrintWrter的類型。您可以添加一些魔法，以便您只需要List(in, out)，使用類型A時使用multiple ORed type bounds即可。

通過定義一些非常冒險和危險的隱式轉換，您可以避免必須鍵入List（以及另一種避開指定資源類型的方法），但是我沒有記錄詳細信息，因爲它太危險了。

Answer 6

從程序路徑中分離清理算法是一個好主意。

該解決方案可讓您累積範圍內的可關閉數據。
範圍清理將在塊執行後發生，或者範圍可以分離。隨後可以對範圍進行清潔。

通過這種方式，我們可以獲得與單線程編程相同的便利性。

實用類：

import java.io.Closeable 

object ManagedScope { 
    val scope=new ThreadLocal[Scope](); 
    def managedScope[T](inner: =>T):T={ 
    val previous=scope.get(); 
    val thisScope=new Scope(); 
    scope.set(thisScope); 
    try{ 
     inner 
    } finally { 
     scope.set(previous); 
     if(!thisScope.detatched) thisScope.close(); 
    } 
    } 

    def closeLater[T <: Closeable](what:T): T = { 
    val theScope=scope.get(); 
    if(!(theScope eq null)){ 
     theScope.closeables=theScope.closeables.:+(what); 
    } 
    what; 
    } 

    def detatchScope(): Scope={ 
    val theScope=scope.get(); 
    if(theScope eq null) null; 
    else { 
     theScope.detatched=true; 
     theScope; 
    } 
    } 
} 

class Scope{ 
    var detatched=false; 
    var closeables:List[Closeable]=List(); 

    def close():Unit={ 
    for(c<-closeables){ 
     try{ 
     if(!(c eq null))c.close(); 
     } catch{ 
     case e:Throwable=>{}; 
     } 
    } 
    } 
} 

用法：

def checkSocketConnect(host:String, portNumber:Int):Unit = managedScope { 
    // The close later function tags the closeable to be closed later 
    val socket = closeLater(new Socket(host, portNumber)); 
    doWork(socket); 
    } 

    def checkFutureConnect(host:String, portNumber:Int):Unit = managedScope { 
    // The close later function tags the closeable to be closed later 
    val socket = closeLater(new Socket(host, portNumber)); 
    val future:Future[Boolean]=doAsyncWork(socket); 

    // Detatch the scope and use it in the future. 
    val scope=detatchScope(); 
    future.onComplete(v=>scope.close()); 
    }