¿Cómo se puede heredar un método de fábrica genérico?

Question

Supongamos que tiene una Persona de clase y crea una clase de colección extendiéndola, p. ArrayBuffer:

class Persons extends ArrayBuffer[Person] { 
// methods operation on the collection 
} 

Ahora, con ArrayBuffer, puede crear una colección con el método de aplicación() en el objeto acompañante, por ejemplo:

ArrayBuffer(1, 2, 3) 

¿Quieres ser capaz de hacer lo mismo con las personas, por ejemplo:

Persons(new Person("John", 32), new Person("Bob", 43)) 

Mi primera intuición aquí era ampliar el objeto compañero ArrayBuffer y conseguir el método de aplicación() de forma gratuita. Pero parece que no puedes extender objetos. (No estoy seguro de por qué.)

La siguiente idea era crear un objeto Personas con un apply() llama al método que se aplican método de ArrayBuffer:

object Persons { 
    def apply(ps: Person*) = ArrayBuffer(ps: _*) 
} 

Sin embargo, este devuelve una ArrayBuffer [Persona] y no una Persona.

Después de algo de investigación en el scaladoc y fuente de ArrayBuffer, me ocurrió lo siguiente, lo cual pensé que haría que las personas objeto heredará aplicar() desde GenericCompanion:

EDIT:

object Persons extends SeqFactory[ArrayBuffer] { 
    def fromArrayBuffer(ps: ArrayBuffer[Person]) = { 
     val persons = new Persons 
     persons appendAll ps 
     persons 
    } 

    def newBuilder[Person]: Builder[Person, Persons] = new ArrayBuffer[Person] mapResult fromArrayBuffer 
} 

sin embargo, se da el siguiente mensaje de error:

<console>:24: error: type mismatch; 
found : (scala.collection.mutable.ArrayBuffer[Person]) => Persons 
required: (scala.collection.mutable.ArrayBuffer[Person(in method newBuilder)]) 
=> Persons 
     def newBuilder[Person]: Builder[Person, Persons] = new ArrayBuffer[Perso 
n] mapResult fromArrayBuffer 
      ^

Tal vez esto me debe desestimulan de ir más lejos, pero estoy teniendo un gran tiempo learnin g Scala y realmente me gustaría que esto funcione. Por favor dime si estoy en el camino equivocado. :)

Answer 1

En lugar de extender ArrayBuffer[Person] directamente, puede usar el pimp my library pattern. La idea es hacer que Persons y ArrayBuffer[Person] sean completamente intercambiables.

class Persons(val self: ArrayBuffer[Person]) extends Proxy { 
    def names = self map { _.name } 

    // ... other methods ... 
} 

object Persons { 
    def apply(ps: Person*): Persons = ArrayBuffer(ps: _*) 

    implicit def toPersons(b: ArrayBuffer[Person]): Persons = new Persons(b) 

    implicit def toBuffer(ps: Persons): ArrayBuffer[Person] = ps.self 
} 

La conversión implícita en el objeto acompañante Personas le permite utilizar cualquier método ArrayBuffer cada vez que tenga una referencia Personas y viceversa.

Por ejemplo, se puede hacer

val l = Persons(new Person("Joe")) 
(l += new Person("Bob")).names 

Tenga en cuenta que es una lPersons, pero se puede llamar al método ArrayBuffer.+= en él porque el compilador añadirá automáticamente en una llamada a Persons.toBuffer(l). El resultado del método += es ArrayBuffer, pero puede llamar al Person.names porque el compilador inserta una llamada al Persons.toPersons.

Editar:

Puede generalizar esta solución con tipos más altos kinded:

class Persons[CC[X] <: Seq[X]](self: CC[Person]) extends Proxy { 
    def names = self map (_.name) 
    def averageAge = { 
     self map (_.age) reduceLeft { _ + _ }/
      (self.length toDouble) 
    } 
    // other methods 
} 

object Persons { 
    def apply(ps: Person*): Persons[ArrayBuffer] = ArrayBuffer(ps: _*) 

    implicit def toPersons[CC[X] <: Seq[X]](c: CC[Person]): Persons[CC] = 
     new Persons[CC](c) 

    implicit def toColl[CC[X] <: Seq[X]](ps: Persons[CC]): CC[Person] = 
     ps.self 
} 

Esto le permite hacer cosas como

List(new Person("Joe", 38), new Person("Bob", 52)).names 

o

val p = Persons(new Person("Jeff", 23)) 
p += new Person("Sam", 20) 

Tenga en cuenta que en el último ejemplo, estamos llamando al += en un Persons. Esto es posible porque Persons "recuerda" el tipo de colección subyacente y le permite llamar a cualquier método definido en ese tipo (ArrayBuffer en este caso, debido a la definición de Persons.apply).

Answer 2

Además de la solución de anovstrup, ¿el ejemplo siguiente no hará lo que usted quiere?

case class Person(name: String, age: Int) 

class Persons extends ArrayBuffer[Person] 

object Persons { 
    def apply(ps: Person*) = { 
     val persons = new Persons 
     persons appendAll(ps) 
     persons 
    } 
} 

scala> val ps = Persons(new Person("John", 32), new Person("Bob", 43)) 
ps: Persons = ArrayBuffer(Person(John,32), Person(Bob,43)) 

scala> ps.append(new Person("Bill", 50)) 

scala> ps 
res0: Persons = ArrayBuffer(Person(John,32), Person(Bob,43), Person(Bill,50))