Verwendung von scala.util.control.Exception

Question

Hat jemand gute Beispiele für die Verwendung scala.util.control.Exception version 2.12.0 (version 2.8.0),? Ich kämpfe, um es von den Typen herauszufinden.

Answer 1

In der Tat - ich finde es auch ziemlich verwirrend! Hier ist ein Problem, wo ich eine Eigenschaft haben, die ein parseable veraltet sein können:

def parse(s: String) : Date = new SimpleDateFormat("yyyy-MM-dd").parse(s) 
def parseDate = parse(System.getProperty("foo.bar")) 

type PE = ParseException 
import scala.util.control.Exception._ 

val d1 = try { 
      parseDate 
      } catch { 
      case e: PE => new Date 
      } 

Schalt dies auf eine funktionelle Form:

val date = 
    catching(classOf[PE]) either parseDate fold (_ => new Date, identity(_)) 

In dem obigen Code, schaltet sich catching(t) either expr in einem Either[T, E] führen wird, wo T ist der Typ des Throwable und E ist der Typ des Ausdrucks. Dieser kann dann über eine fold in einen bestimmten Wert umgewandelt werden.

Oder eine andere Version wieder:

val date = 
    handling(classOf[PE]) by (_ => new Date) apply parseDate 

Dies ist vielleicht ein wenig klarer - das sind äquivalent:

handling(t) by g apply f 
try { f } catch { case _ : t => g } 

Answer 2

Hier einige Beispiele:

Compiler/scala/tools/nsc/interpreter/InteractiveReader.scala

def readLine(prompt: String): String = { 
    def handler: Catcher[String] = { 
     case e: IOException if restartSystemCall(e) => readLine(prompt) 
    } 
    catching(handler) { readOneLine(prompt) } 
    } 

Compiler/scala/tools/nsc/Interpreter.scala

/** We turn off the binding to accomodate ticket #2817 */ 
    def onErr: Catcher[(String, Boolean)] = { 
    case t: Throwable if bindLastException => 
     withoutBindingLastException { 
     quietBind("lastException", "java.lang.Throwable", t) 
     (stringFromWriter(t.printStackTrace(_)), false) 
     } 
    } 

    catching(onErr) { 
    unwrapping(wrapperExceptions: _*) { 
     (resultValMethod.invoke(loadedResultObject).toString, true) 
    } 
    } 

... 

    /** Temporarily be quiet */ 
    def beQuietDuring[T](operation: => T): T = { 
    val wasPrinting = printResults 
    ultimately(printResults = wasPrinting) { 
     printResults = false 
     operation 
    } 
    } 

    /** whether to bind the lastException variable */ 
    private var bindLastException = true 

    /** Temporarily stop binding lastException */ 
    def withoutBindingLastException[T](operation: => T): T = { 
    val wasBinding = bindLastException 
    ultimately(bindLastException = wasBinding) { 
     bindLastException = false 
     operation 
    } 
    } 

Compiler/scala/tools/nsc/io/Process.scala

def exitValue(): Option[Int] = 
    catching(classOf[IllegalThreadStateException]) opt process.exitValue() 

Bibliothek/scala/xml/include/sax /Main.scala

def saxe[T](body: => T) = catching[T](classOf[SAXException]) opt body 

... 

    ignoring(classOf[SAXException]) { 
    includer.setProperty(lexicalHandler, s) 
    s setFilter includer 
    }