Частично примененный тип лямбда в Scala с добрым проектором - PullRequest
Новая
       69

Частично примененный тип лямбда в Scala с добрым проектором

6 голосов
/ 21 марта 2019

Рассмотрим следующее определение типа: 

trait LiftF[F[_], G[_]] {
  def liftF[A](fa: F[A]): G[A]
}

При предоставлении требования для неявного этого типа в контексте контекста (используя плагин типа кинопроектора) мы должны написать его так: 

def func[A, G[_], F[_]: LiftF[?[_], G]](a: F[A]): G[A]

Я хотел бы избавиться от части ?[_], поэтому мое первоначальное предположение состояло в том, чтобы написать тип To[G[_]], который возвращает LiftF[?[_], G], чтобы преобразовать приведенное выше определение функции в 

def func[A, G[_], F[_]: LiftF.To[G]](a: F[A]): G[A]

Однако при записи определения типа To как 

type To[G[_]] = LiftF[?[_], G]

я получаю следующую ошибку компиляции: 

Error:(17, 20) type Λ$ takes type parameters
type To[G[_]] = LiftF[?[_], G]

Попытка переписать его с экзистенциальными типами приводит к следующему определению типа:

type To[G[_]] = LiftF[F, G] forSome { type F[X] }

Это прекрасно компилируется, но, что не удивительно, не может быть применено к другим параметрам типа, поэтому определение желаемой функции не может быть достигнуто.

Мне удалось реализовать "частичное приложение""часть с кодом, вдохновленным шаблоном aux: 

trait To[G[_]] {
  type From[F[_]] = LiftF[F, G]
}

К сожалению, это оставляет меня с синтаксисом, который, возможно, хуже оригинального: 

def func[A, G[_], F[_]: LiftF.To[G]#From](a: F[A]): G[A]

У меня вопрос - могу ли я добиться изначально предложенного синтаксиса в Scala с помощью доброжелательного проектора, или я должен просто придерживаться ?[_]?

1 Ответ

6 голосов
/ 21 марта 2019

Насколько я понимаю, добрый проектор не может вам здесь помочь: 

type To[G[_]] = LiftF[?[_], G]

будет просто механически переписан во что-то вроде 

type To[G[_]] = ({ type T[F[_]] = LiftF[F, G] })#T

, но этонедопустим в 2.12.x, потому что он ожидает простой тип вида * в правой части определения.

Если вы переместите параметр F в левую часть, вы получите

type To[G[_], F[_]] = LiftF[F, G]

, который вы затем должны использовать как To[G, ?[_]], который, очевидно, тоже ничего не покупает, он просто меняет порядок аргументов.Поэтому я бы предложил просто использовать LiftF[?[_], G] и утешиться тем фактом, что вам не нужно явно писать ({ type L[F[_]] = LiftF[F, G] })#L.

Кстати, в Dotty это работает простоштраф: 

trait LiftF[F[_], G[_]] {
  def liftF[A](fa: F[A]): G[A]
}

type To[G[_]] = [F[_]] => LiftF[F, G]
def f[A, G[_], F[_]: To[G]](a: F[A]): G[A] = implicitly[LiftF[F, G]].liftF(a)
...