Вывод типа в анонимных функциях с помощью enrich-my-library

Скажем, у меня есть метод, который превращает (функция на два элемента) в (функция на две последовательности):

def seqed[T](f: (T,T) => T): (Seq[T], Seq[T]) => Seq[T] = (_,_).zipped map f

На словах результирующая функция занимает две последовательности xs а также ysи создает новую последовательность, состоящую из (xs(0) f ys(0), xs(1) f ys(1), ...)Так, например, если xss является Seq(Seq(1,2),Seq(3,4)) а также f является (a: Int, b: Int) => a + bмы можем вызвать это так:

xss reduceLeft seqed(f)         // Seq(4, 6)

или с анонимной функцией:

xss reduceLeft seqed[Int](_+_)

Это довольно хорошо; было бы неплохо избавиться от [Int] введите аргумент, но я не вижу, как (какие-либо идеи?).

Чтобы сделать это немного больше похоже на tupled Метод, я также попробовал шаблон enrich-my-library:

class SeqFunction[T](f: (T,T) => T) {
  def seqed: (Seq[T], Seq[T]) => Seq[T] = (_,_).zipped map f
}
implicit def seqFunction[T](f: (T,T) => T) = new SeqFunction(f)

Для предопределенной функции это прекрасно работает, но уродливо с анонимными

xss reduceLeft f.seqed
xss reduceLeft ((_:Int) + (_:Int)).seqed

Есть ли другой способ переформулировать это так, чтобы типы выводились, и я мог использовать синтаксис что-то вроде:

// pseudocode
xss reduceLeft (_+_).seqed         // ... or failing that
xss reduceLeft (_+_).seqed[Int]

? Или я слишком много спрашиваю о выводе типа?

Источник

3 ответа

Решение

Причина, по которой аннотация типа требуется в

xss reduceLeft seqed[Int](_+_)

но не в

xs zip ys map Function.tupled(_+_)

из-за разницы в требованиях типа между map а также reduceLeft,

def reduceLeft [B >: A] (f: (B, A) ⇒ B): B 
def map        [B]      (f: (A) ⇒ B): Seq[B]   // simple version!

reduceLeft надеется seqed вернуть тип B где B >: Int, Похоже, поэтому точный тип для seqed не может быть известно, поэтому мы должны предоставить аннотацию. Больше информации в этом вопросе.

Одним из способов преодоления этого является повторное внедрение reduceLeft без нижней границы.

implicit def withReduceL[T](xs: Seq[T]) = new {
  def reduceL(f: (T, T) => T) = xs reduceLeft f
}

Тестовое задание:

scala> Seq(Seq(1,2,3), Seq(2,2,2)) reduceL seqed(_+_)
res1: Seq[Int] = List(3, 4, 5)

Проблема в том, что теперь это не работает на подтипах Seq (например List), с или без [Int] параметр:

scala> Seq(List(1,2,3), List(2,2,2)) reduceL seqed(_+_)
<console>:11: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2))
              Seq(List(1,2,3), List(2,2,2)) reduceL seqed(_+_)
                                                          ^

reduceL ожидает функцию типа (List[Int], List[Int]) => List[Int], Так как Function2 определяется как Function2 [-T1, -T2, +R], (Seq[Int], Seq[Int]) => Seq[Int] не является допустимой заменой.

Источник

Вы не можете делать это так, как вы хотите, но посмотрите на Function.tupled, который является противоположностью .tupled это решает эту самую проблему.

scala> List(1, 2, 3) zip List(1, 2, 3) map (_ + _).tupled
<console>:8: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2))
              List(1, 2, 3) zip List(1, 2, 3) map (_ + _).tupled
                                                   ^
<console>:8: error: missing parameter type for expanded function ((x$1: <error>, x$2) => x$1.$plus(x$2))
              List(1, 2, 3) zip List(1, 2, 3) map (_ + _).tupled
                                                       ^

scala> List(1, 2, 3) zip List(1, 2, 3) map Function.tupled(_ + _)
res7: List[Int] = List(2, 4, 6)
Источник

Я уверен, что вы слишком много просите. Вывод типа в Scala идет слева направо, поэтому тип (_+_) необходимо выяснить, прежде чем даже рассмотреть .sedeq часть. И там недостаточно информации.

Источник
Другие вопросы по тегам