Web 上で Scala の ARM (自動リソース管理) の例をたくさん見てきました。ほとんどはお互いにかなり似ていますが、それを書くのは通過儀礼のようです. ただし、継続を使用したかなりクールな例を見ました。
いずれにせよ、そのコードの多くには何らかの欠陥があります。そのため、最も正確で適切なバージョンを投票できる Stack Overflow で参照することをお勧めします。
21453 次
10 に答える
75
2009 年 3 月 26 日のChris Hansen のブログ エントリ「ARM Blocks in Scala: Revisited」では、Martin OderskyのFOSDEM プレゼンテーションのスライド 21 について説明しています。この次のブロックは、スライド 21 から直接引用したものです (許可を得て)。
def using[T <: { def close() }]
(resource: T)
(block: T => Unit)
{
try {
block(resource)
} finally {
if (resource != null) resource.close()
}
}
--引用終了--
次に、次のように呼び出すことができます。
using(new BufferedReader(new FileReader("file"))) { r =>
var count = 0
while (r.readLine != null) count += 1
println(count)
}
このアプローチの欠点は何ですか? そのパターンは、自動リソース管理が必要な場所の 95% に対応しているようです...
編集：コードスニペットを追加
Edit2:withデザインパターンの拡張 - Pythonステートメントとアドレス指定からインスピレーションを得ています:
- ブロックの前に実行するステートメント
- 管理対象リソースに応じて例外を再スローする
- 1 つの using ステートメントで 2 つのリソースを処理する
- 暗黙的な変換と
Managedクラスを提供することによるリソース固有の処理
これは Scala 2.8 の場合です。
trait Managed[T] {
def onEnter(): T
def onExit(t:Throwable = null): Unit
def attempt(block: => Unit): Unit = {
try { block } finally {}
}
}
def using[T <: Any](managed: Managed[T])(block: T => Unit) {
val resource = managed.onEnter()
var exception = false
try { block(resource) } catch {
case t:Throwable => exception = true; managed.onExit(t)
} finally {
if (!exception) managed.onExit()
}
}
def using[T <: Any, U <: Any]
(managed1: Managed[T], managed2: Managed[U])
(block: T => U => Unit) {
using[T](managed1) { r =>
using[U](managed2) { s => block(r)(s) }
}
}
class ManagedOS(out:OutputStream) extends Managed[OutputStream] {
def onEnter(): OutputStream = out
def onExit(t:Throwable = null): Unit = {
attempt(out.close())
if (t != null) throw t
}
}
class ManagedIS(in:InputStream) extends Managed[InputStream] {
def onEnter(): InputStream = in
def onExit(t:Throwable = null): Unit = {
attempt(in.close())
if (t != null) throw t
}
}
implicit def os2managed(out:OutputStream): Managed[OutputStream] = {
return new ManagedOS(out)
}
implicit def is2managed(in:InputStream): Managed[InputStream] = {
return new ManagedIS(in)
}
def main(args:Array[String]): Unit = {
using(new FileInputStream("foo.txt"), new FileOutputStream("bar.txt")) {
in => out =>
Iterator continually { in.read() } takeWhile( _ != -1) foreach {
out.write(_)
}
}
}
于 2010-02-08T03:59:21.560 に答える
63
ダニエル、
最近、自動リソース管理用に scala-arm ライブラリをデプロイしました。ここでドキュメントを見つけることができます: https://github.com/jsuereth/scala-arm/wiki
このライブラリは、3 つの使用スタイルをサポートしています (現在)。
1) 命令/式:
import resource._
for(input <- managed(new FileInputStream("test.txt")) {
// Code that uses the input as a FileInputStream
}
2) モナディックスタイル
import resource._
import java.io._
val lines = for { input <- managed(new FileInputStream("test.txt"))
val bufferedReader = new BufferedReader(new InputStreamReader(input))
line <- makeBufferedReaderLineIterator(bufferedReader)
} yield line.trim()
lines foreach println
3) 区切られた継続スタイル
「エコー」TCPサーバーは次のとおりです。
import java.io._
import util.continuations._
import resource._
def each_line_from(r : BufferedReader) : String @suspendable =
shift { k =>
var line = r.readLine
while(line != null) {
k(line)
line = r.readLine
}
}
reset {
val server = managed(new ServerSocket(8007)) !
while(true) {
// This reset is not needed, however the below denotes a "flow" of execution that can be deferred.
// One can envision an asynchronous execuction model that would support the exact same semantics as below.
reset {
val connection = managed(server.accept) !
val output = managed(connection.getOutputStream) !
val input = managed(connection.getInputStream) !
val writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(output)))
val reader = new BufferedReader(new InputStreamReader(input))
writer.println(each_line_from(reader))
writer.flush()
}
}
}
コードは Resource タイプ特性を使用するため、ほとんどのリソース タイプに適応できます。close メソッドまたは dispose メソッドのいずれかを使用して、クラスに対して構造型付けを使用するためのフォールバックがあります。ドキュメントをチェックして、追加すべき便利な機能があれば教えてください。
于 2010-08-09T13:42:04.180 に答える
18
継続を使用したJames Iryのソリューションは次のとおりです。
// standard using block definition
def using[X <: {def close()}, A](resource : X)(f : X => A) = {
try {
f(resource)
} finally {
resource.close()
}
}
// A DC version of 'using'
def resource[X <: {def close()}, B](res : X) = shift(using[X, B](res))
// some sugar for reset
def withResources[A, C](x : => A @cps[A, C]) = reset{x}
比較のために、継続がある場合とない場合のソリューションを次に示します。
def copyFileCPS = using(new BufferedReader(new FileReader("test.txt"))) {
reader => {
using(new BufferedWriter(new FileWriter("test_copy.txt"))) {
writer => {
var line = reader.readLine
var count = 0
while (line != null) {
count += 1
writer.write(line)
writer.newLine
line = reader.readLine
}
count
}
}
}
}
def copyFileDC = withResources {
val reader = resource[BufferedReader,Int](new BufferedReader(new FileReader("test.txt")))
val writer = resource[BufferedWriter,Int](new BufferedWriter(new FileWriter("test_copy.txt")))
var line = reader.readLine
var count = 0
while(line != null) {
count += 1
writer write line
writer.newLine
line = reader.readLine
}
count
}
Tiark Rompf の改善案は次のとおりです。
trait ContextType[B]
def forceContextType[B]: ContextType[B] = null
// A DC version of 'using'
def resource[X <: {def close()}, B: ContextType](res : X): X @cps[B,B] = shift(using[X, B](res))
// some sugar for reset
def withResources[A](x : => A @cps[A, A]) = reset{x}
// and now use our new lib
def copyFileDC = withResources {
implicit val _ = forceContextType[Int]
val reader = resource(new BufferedReader(new FileReader("test.txt")))
val writer = resource(new BufferedWriter(new FileWriter("test_copy.txt")))
var line = reader.readLine
var count = 0
while(line != null) {
count += 1
writer write line
writer.newLine
line = reader.readLine
}
count
}
于 2010-02-13T22:08:15.070 に答える
7
Scala で ARM を実行するための段階的な 4 ステップの進化が見られます。
- アームなし：ダート
- クロージャーのみ: より良いが、複数のネストされたブロック
- 継続モナド: For を使用してネストを平坦化しますが、2 つのブロックで不自然に分離します
- 直接的なスタイルの継続: ニラヴァ、あはは! これは最も型安全な代替手段でもあります: withResource ブロックの外側のリソースは型エラーになります。
于 2010-02-08T03:11:44.677 に答える
6
軽量 (10 行のコード) ARM がより良いファイルに含まれています。参照: https://github.com/pathikrit/better-files#lightweight-arm
import better.files._
for {
in <- inputStream.autoClosed
out <- outputStream.autoClosed
} in.pipeTo(out)
// The input and output streams are auto-closed once out of scope
ライブラリ全体が必要ない場合の実装方法は次のとおりです。
type Closeable = {
def close(): Unit
}
type ManagedResource[A <: Closeable] = Traversable[A]
implicit class CloseableOps[A <: Closeable](resource: A) {
def autoClosed: ManagedResource[A] = new Traversable[A] {
override def foreach[U](f: A => U) = try {
f(resource)
} finally {
resource.close()
}
}
}
于 2015-10-10T17:50:37.883 に答える