Чтобы поместить вещи в контекст: Этот ответ был первоначально размещен в другой теме. Вы видите это здесь, потому что два потока были объединены. Постановка вопроса в указанной ветке выглядела следующим образом:
Как разрешить определение этого типа: Pure [({type? [A] = (R, a)}) #?]?
Каковы причины использования такой конструкции?
Snipped поставляется из библиотеки scalaz:
trait Pure[P[_]] {
def pure[A](a: => A): P[A]
}
object Pure {
import Scalaz._
//...
implicit def Tuple2Pure[R: Zero]: Pure[({type ?[a]=(R, a)})#?] = new Pure[({type ?[a]=(R, a)})#?] {
def pure[A](a: => A) = (Ø, a)
}
//...
}
Ответ:
trait Pure[P[_]] {
def pure[A](a: => A): P[A]
}
Подчеркивание в полях после P подразумевает, что это конструктор типов, принимает один тип и возвращает другой тип. Примеры конструкторов типов с таким видом: List, Option.
Дайте List a Int, конкретный тип, и это даст вам List[Int], другой конкретный тип. Дайте List a String, и это даст вам List[String]. И т.д.
Итак, List, Option можно считать функциями уровня типа arity 1. Формально мы говорим, что они имеют вид * -> *. Звездочкой обозначен тип.
Теперь Tuple2[_, _] - это конструктор типов с видом (*, *) -> *, т. Е. Вам нужно дать ему два типа, чтобы получить новый тип.
Поскольку их подписи не совпадают, вы не можете заменить Tuple2 на P. Вам нужно частично применить Tuple2 к одному из его аргументов, что даст нам конструктор типа вида * -> *, и мы можем заменить его на P.
К сожалению, в Scala нет специального синтаксиса для частичного применения конструкторов типов, и поэтому нам приходится прибегать к чудовищу, называемому типом lambdas. (Что у вас есть в вашем примере.) Они называются так, потому что они аналогичны лямбда-выражениям, существующим на уровне значений.
Может помочь следующий пример:
// VALUE LEVEL
// foo has signature: (String, String) => String
scala> def foo(x: String, y: String): String = x + " " + y
foo: (x: String, y: String)String
// world wants a parameter of type String => String
scala> def world(f: String => String): String = f("world")
world: (f: String => String)String
// So we use a lambda expression that partially applies foo on one parameter
// to yield a value of type String => String
scala> world(x => foo("hello", x))
res0: String = hello world
// TYPE LEVEL
// Foo has a kind (*, *) -> *
scala> type Foo[A, B] = Map[A, B]
defined type alias Foo
// World wants a parameter of kind * -> *
scala> type World[M[_]] = M[Int]
defined type alias World
// So we use a lambda lambda that partially applies Foo on one parameter
// to yield a type of kind * -> *
scala> type X[A] = World[({ type M[A] = Foo[String, A] })#M]
defined type alias X
// Test the equality of two types. (If this compiles, it means they're equal.)
scala> implicitly[X[Int] =:= Foo[String, Int]]
res2: =:=[X[Int],Foo[String,Int]] = <function1>
Edit:
Больше параллелей уровня значений и уровня типа.
// VALUE LEVEL
// Instead of a lambda, you can define a named function beforehand...
scala> val g: String => String = x => foo("hello", x)
g: String => String = <function1>
// ...and use it.
scala> world(g)
res3: String = hello world
// TYPE LEVEL
// Same applies at type level too.
scala> type G[A] = Foo[String, A]
defined type alias G
scala> implicitly[X =:= Foo[String, Int]]
res5: =:=[X,Foo[String,Int]] = <function1>
scala> type T = World[G]
defined type alias T
scala> implicitly[T =:= Foo[String, Int]]
res6: =:=[T,Foo[String,Int]] = <function1>
В представленном случае параметр типа R является локальным для функции Tuple2Pure, и поэтому вы не можете просто определить type PartialTuple2[A] = Tuple2[R, A], потому что просто нет места, где вы можете поместить этот синоним.
Чтобы справиться с таким случаем, я использую следующую уловку, которая использует члены типа. (Надеюсь, этот пример не требует пояснений.)
scala> type Partial2[F[_, _], A] = {
| type Get[B] = F[A, B]
| }
defined type alias Partial2
scala> implicit def Tuple2Pure[R]: Pure[Partial2[Tuple2, R]#Get] = sys.error("")
Tuple2Pure: [R]=> Pure[[B](R, B)]