Perché questo tipo strutturale legato non funziona come previsto?

Question

Sto cercando di scrivere un semplice metodo di supporto che riceve qualcosa che può essere chiuso e qualche funzione che riceve le prime e garantisce la "richiudibile" è chiuso dopo l'esecuzione della funzione.

Per esempio, io voglio usare in questo modo:

  closing(new FileOutputStream("/asda"))(_.write("asas"))

Il mio impl è

object Helpers {

  def closing[T <: { def close }](closeable: T)(action: T => Unit): Unit =
    try action apply closeable finally closeable close

}

Ma quando si cerca di compilare questo semplice test:

object Test {

  import Helpers._

  closing(new FileOutputStream("/asda"))(_.write("asas"))

}

Il compilatore si lamenta con:

argomenti di tipo inferite [Java.io.FileOutputStream] non fare conforme al tipo di metodo di chiusura limiti dei parametri [T <: AnyRef {def chiuso: Unità}]

Tutte le idee perché?

Answer 1

Hai bisogno di scrivere

def closing[T <: { def close() }]

v'è una differenza di Scala tra i metodi con parentesi e metodi vuoti senza parentesi affatto.

Answer 2

limiti tipo sono difficili. In particolare, Scala tiene traccia del numero di elenchi di parametri in aggiunta ai parametri stessi. Provate questi fuori!

class A { def f = 5 }
class B { def f() = 5 }
class C { def f()() = 5 }
def useA[X <: { def f: Int }](x: X) = x.f
def useB[X <: { def f(): Int }](x: X) = x.f
def useC[X <: { def f()(): Int}](x: X) = x.f

useA(new A)  // This works, but what other combinations do?

Nel tuo caso, si desidera

def closing[T <: { def close() }] ...

P.S. Se davvero pensa di utilizzare questo molto, probabilmente dovrebbe anche giocare con

class D extends B { override def f = 6 }
class E extends A { override def f() = 6 }

e vedere quali use è necessario utilizzare in ogni caso.