Как сделать класс flatMappable?

Question

Я нахожу, что хочу, чтобы написать это:

def allAsAndFs(node: Node): PairOfSeqs[Action, Factor] = 
    node.regularNames.flatMap { name => regularAsAndFs(name) } ++ 
    node.specialNames.flatMap { name => specialAsAndFs(name) } 

где:

def regularNames: Seq[String] 
def specialNames: Seq[String] 

def regularAsAndFs(name: String): PairOfSeqs[Action, Factor] 
def specialAsAndFs(name: String): PairOfSeqs[Action, Factor] 

и:

class PairOfSeqs[A, B](as: Seq[A], bs: Seq[B]) { 
    def ++(that: PairOfSeqs[A, B]): PairOfSeqs[A, B] = 
    PairOfSeqs(as ++ that.as, bs ++ that.bs) 
    . . . 
} 

Что мне нужно сделать, чтобы flatMap сливаться в PairsOfSeqs по , вызывающий соответствующий метод ++?

Похоже PairOfSeqs должна распространяться GenTraversableOnce, но GenTraversableOnce имеет довольно удивительные 47 абстрактные методы для переопределения.

Что такое идиоматический, скалистический способ сделать это?

Answer 1

Вы используете несколько нестандартную идею flatMap. Нормальный тип подписи

class C[A] { 
    def flatMap[B](f: A => C[B]): C[B] = ??? 
} 

Но вы хотите (что-то похожее на - это не компилируется):

def foo[D <: { def ++(d: D): D }](f: A => D): D 

который гораздо больше похож fold чем flatMap.

Одна из возможностей состоит в том, чтобы сделать PairOfSeqs полноценной коллекцией. Это будет сложно, потому что типы действительно не выстраиваются так хорошо, и потому что расширение коллекций затруднено. (Соотношение вознаграждение/усилие может быть хорошо, потому что даже несмотря на усилия, большая награда огромный, если вам действительно нужно.)

Возможно лучшая возможность просто иметь метод расширения на Seq.

case class PairOfSeqs[A, B](as: Seq[A], bs: Seq[B]) { 
    def ++(that: PairOfSeqs[A, B]): PairOfSeqs[A,B] = 
    PairOfSeqs(as ++ that.as, bs ++ that.bs) 
} 

implicit class SeqCanPairMap[A](val underlying: Seq[A]) extends AnyVal { 
    def flatPair[B,C](f: A => PairOfSeqs[B,C]): PairOfSeqs[B,C] = { 
    val ps = underlying.map(f) 
    PairOfSeqs(ps.map(_.as).fold(Seq[B]())(_ ++ _), ps.map(_.bs).fold(Seq[C]())(_ ++ _)) 
    } 
} 

Seq("fish", "fowl").flatPair(s => new PairOfSeqs(s.map(_.toChar), s.map(_.toInt))) 

Есть множество других вариантов (например, определить более традиционные flatMap на PairOfSeqs, и переход от регулярных seqs к PairOfSeqs с пустым вторым слотом), но это, вероятно, покрывает ваш случай использования достаточно хорошо.

И наконец, чтобы сделать класс flatMappable, все, что вам нужно сделать, это определить flatMap. В частности, для понимания можно использовать его. (Но вам тоже понадобится map)