Scala несоответствие типов высшего kinded типа

Question

Я хотел бы моделировать Mapper, который принимает в контейнере A с (T[A]), так что с функцией f: A => B мы получаем другой контейнер T[B]. У меня, после многих часов экспериментов (см комментировал код) придумали следующее решение:

sealed trait Mapper[ A, T[ A ], B ] { 
    //type Out <: T[B] 
    type Out[X] //= T[X] 
    def map(l: T[ A ], f: A => B): Out[B] 
    } 

    object Mappers { 

    implicit def typedMapper[ A, T[ A ] <: Iterable[ A ], B ]: Mapper[ A, T, B ] = 
     new Mapper[ A, T, B ] { 
     override type Out[X] = Iterable[X] 
     //override type Out <: Iterable[ B ] 
     //def map(l: T[ A ], f: A => B) : this.Out = { 
     def map(l: T[ A ], f: A => B) : Out[B] = { 
      println("map") 
      l.map(f) 
     } 
     } 

    implicit def IntMapper = typedMapper[Int, List, Int] 
    } 

    //def testMapper[ A, T[ A ], B ](l: T[ A ], f: A => B)(implicit mapper: Mapper[ A, T, B ]): T[B] = { 
    def testMapper[ A, T[ A ], B ](l: T[ A ], f: A => B)(implicit mapper: Mapper[ A, T, B ]) : Mapper[A, T, B]#Out[B]= { 
    println(mapper) 
    mapper.map(l, f) 
    } 

теперь я могу использовать его следующим образом:

import Mappers.IntMapper 
val l9 = testMapper(List(1, 2, 3), { x: Int => x + 1 }) 
println(l9) 

Хотя это работает я до сих пор потеря как я могу напрямую ограничить Out до T[B]. Если я это сделаю, я всегда получаю несоответствие типа. Может ли кто-нибудь указать более простой/простой способ сделать это без псевдонима типа или напрямую с помощью T[B]?

ТИА

Answer 1

Вот прокомментировал первое приближение к тому, что вы хотите. Члены типа были устранены, что выявило немного более глубокую проблему в том, что вы хотите сделать.

trait Mapper[A, T[_], B] { 
    def map(ta: T[A])(f: A => B): T[B] 
} 

// Note that Iterable[A]#map has type [B](A => B)Iterable[B]. You can't have typedMapper 
// like yours from above just yet, because T#map is not certain to return another T; 
// it only promises an Iterable. 
implicit def iterableMapper[A, B]: Mapper[A, Iterable, B] = new Mapper[A, Iterable, B] { 
    // Multiple param lists support the type inferencer 
    override def map(i: Iterable[A])(f: A => B) = i.map(f) 
} 

// Curried and arg-swapped version of Mapper 
type MapperOf[A, B] = { type l[T[_]] = Mapper[A, T, B] } 
def map[A, B, T[_]: MapperOf[A, B]#l](ta: T[A])(f: A => B): T[B] = implicitly[Mapper[A, T, B]].map(ta)(f) 

map(??? : Iterable[Any])(_.toString) // OK (at compile time, at least :P) 
map(List(1,2,3))(_*2) // NOPE! The inferencer has already decided T = List, before 
         // looking for implicits, so the resolution fails to notice that 
         // iterableMapper would work. 
map[Int, Int, Iterable](List(1,2,3))(_*2) // Works 

Это подталкивает пределы типа inferencer, поэтому вам нужны аргументы типа вручную.

Обратите внимание, что Iterable не имеет особого значения для иерархии коллекций. В основном это связано с тем, что Java имеет это. Для того, чтобы это было должным образом общим для коллекций, вам нужна вкусная CanBuildFrom темная магия.

import collection._, generic._ // Open the gates of hell 

implicit def collectionMapper[A, Coll[A] <: GenTraversableLike[A, Coll[A]], B] 
    (implicit builderFactory: CanBuildFrom[Coll[A], B, Coll[B]]): 
    Mapper[A, Coll, B] = 
    new Mapper[A, Coll, B] { 
    override def map(coll: Coll[A])(f: A => B): Coll[B] = coll.map(f) 
    } 

map(List(1))(_*2): List[Int] // Works 
map(Seq(1).view)(_*2): Seq[Int] // Works, but note how we lose the knowledge of the view 
           // Exercise for the reader: fix that. 
map(BitSet(1))(_*2): SortedSet[Int] // Works, but we lose the BitSet-ness 
            // Another exercise: fix it.