constructores de la clase Scala y tipos abstractos

Question

Quiero utilizar un tipo abstracto en lugar de un parámetro de tipo.

en mis clases genéricas constructor, quiero tener un parámetro de tipo genérico, pero el código no se compila:

class SomeOtherClass(val s: S){ 
    type S 
} 

es "no encontrado: Tipo S" El error del compilador Scala

Si utilizo un parámetro de tipo en lugar de un tipo abstracto, entonces funciona:

class SomeClass[T](val t: T){ 
    //... 
} 

obliga Scala que yo use un parámetro de tipo en lugar de un tipo abstracto, si yo quiero tener una parámetro genérico en el constructor?

¿Hay alguna otra manera de hacerlo?

Answer 1

En ese caso, se ve forzado a utilizar parámetros de tipo genérico. Puedes solucionarlo declarando el tipo fuera de la clase, pero luego necesitarías crear una instancia del contenedor y luego del objeto y se pondría muy rápido.

trait FooDef { 
    type T 
    class Foo(val x: T) 
} 
val ifd = new FooDef { type T = Int } 
val ifoo = new ifd.Foo(5) 
val sfd = new FooDef { type T = String } 
val sfoo = new sfd.Foo("hi") 
def intFoos(f: fd.Foo forSome { val fd: FooDef {type T = Int} }) = f.x + 1 

Answer 2

¿Cómo debe saber el compilador qué tipo debe usar allí? O bien, debe especificar el tipo directamente, lo que no tendría mucho sentido, o usar un genérico. Hay una manera de hacerlo funcionar, pero no creo que te sirva.

class SomeClass(s: SomeClass#S) { 
    type S 
} 

Pero como SomeClass # S no está definido, no hay ninguna instancia de este.

Answer 3

Quizás quieras algo como esto? De esta forma, puede tener varias instancias de AbstractFooFactory produciendo cada una Foo s con un valor diferente para s.

trait AbstractFooFactory { 
    type S 
    def makeFoo(s:S):Foo 
    class Foo(val s:S) {} 
} 

object StringFooFactory extends AbstractFooFactory { 
    override type S = String 
    override def makeFoo(s:String) = new Foo(s) 
} 

val b = StringFooFactory.makeFoo("bar") 
val s:String = b.s 

Answer 4

Cuando no se especifica el tipo de resumen, su clase debe ser abstracta. Entonces no necesitas el parámetro en absoluto. El equivalente con un tipo abstracto sería:

abstract class SomeOtherClass { 
    type S 
    val s: S 
} 

A continuación, en el uso in situ:

val x = new SomeOtherClass { 
    type S = String 
    val s = "abc" 
} 

Sin el parámetro, la clase abstracta aquí es equivalente a un rasgo. Es mejor usar un rasgo porque es menos restrictivo (solo puedes extender una clase base).