Gibt es eine Möglichkeit, in Scala eine Teilmenge von Typparametern anzugeben, um den Rest abzuleiten?

Question

Ich habe eine Klasse, die wie folgt aussieht:

class X[A <: Throwable, B, C](b: B, c: C) 

A, B und C geschlossen werden kann, so kann ich es nur mit instanziiert:

val x = new X(3, 4) 

die mir ein X gibt [Nichts, Int, Int] - oft was ich will.

aber ich möchte manchmal angeben, dass A etwas anderes als Nothing sein soll (sagen Sie AssertionError). Ist dies möglich, ohne auch die Angabe B und C. Ich stellte mir Syntax entlang der Linien von:

val x = new X[AssertionError](3, 4) 
val x = new X[AssertionError, _, _](3, 4) 
val x = new X[AssertionError,,](3, 4) 

aber offensichtlich funktioniert das nicht.

Gibt es eine Syntax dafür, oder kann ich das gleiche Ergebnis erzielen?

Answer 1

Wenn Sie nicht von terse hardcore Syntax Angst haben, könnten Sie type lamdas hierfür verwenden möchten:

Welcome to Scala version 2.10.0-20121205-235900-18481cef9b (OpenJDK 64-Bit Server VM, Java 1.7.0_15). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> case class X[A <: Throwable, B, C](b: B, c: C) 
defined class X 

scala> type P[A,B] = ({type l[a,b] = X[AssertionError, a, b]})#l[A,B] 
defined type alias P 

scala> val x = new P(1,2) 
x: X[AssertionError,Int,Int] = X(1,2) 

Noch eine Art Alias ​​definieren, wie Frank S. Thomas vorgeschlagen, ist ein Weg zu gehen Hier.

Answer 2

Sie könnten eine Art Alias, wo Ihre erste Typ-Parameter festgelegt sind zu AssertionError definieren:

scala> class X[A <: Throwable, B, C](b: B, c: C) 
defined class X 

scala> type XAssertionError[B, C] = X[AssertionError, B, C] 
defined type alias XAssertionError 

scala> val x = new XAssertionError(3,4) 
x: X[java.lang.AssertionError,Int,Int] = X@22fe135d 

Answer 3

Meine Hauptanliegen dieser am Punkt der Verwendung leicht machen sollten (ich würde es vorziehen, nicht zu definieren, haben neue Typen für jede Verwendung, da die Ausnahmetypen oft unterschiedlich sind). Ich fand, dass ich die Begleiter Objekt Fabrik eine Zwischen Fabrik verwenden:

class X[A <: Throwable, B, C](b: B, c: C) { 
} 

trait XFactory[A <: Throwable] { 
    def apply[B, C](b: B, c: C): X[A, B, C] 
} 

object X { 
    def apply[A <: Throwable: Manifest](): XFactory[A] = { 
    new XFactory[A] { 
     override def apply[B, C](b: B, c: C): X[A, B, C] = { 
     new X(b, c) 
     } 
    } 
    } 
} 

val x = X[AssertionError].apply(3,3) 

Der einzige Nachteil ich sehen kann, ist, dass Sie die „Übernehmen“ zu buchstabieren haben.

Answer 4

Hier ist meine Lösung:

scala> class X[A <: Throwable, B, C](b: B, c: C) 
defined class X 

scala> class Builder[A <: Throwable] { 
    | def apply[B, C](b: B, c: C) = new X[A,B,C](b,c) 
    | } 
defined class Builder 

scala> def X[A <: Throwable]: Builder[A] = new Builder[A] 
X: [A <: Throwable]=> Builder[A] 

scala> val x = X[AssertionError](3, 4) 
x: X[AssertionError,Int,Int] = X@2fc709 

Answer 5

Sie könnten einen Konstruktor mit einem Standardargument nur definieren.

scala> class X[A <: Throwable, B, C](b: B, c: C, clz:Class[_ <: A] = classOf[Nothing]) 
defined class X 

scala> new X(1,2) 
res0: X[Nothing,Int,Int] = X@16de4e1 

scala> new X(1,2, classOf[AssertionError]) 
res1: X[AssertionError,Int,Int] = X@1e41869