Aby nadać kontekst: ta odpowiedź została pierwotnie opublikowana w innym wątku. Widzisz to tutaj, ponieważ dwa wątki zostały połączone. Pytanie we wspomnianym wątku brzmiało następująco:
Jak rozwiązać tę definicję typu: Pure [({type? [A] = (R, a)}) #?]?
Jakie są powody stosowania takiej konstrukcji?
Snipped pochodzi z biblioteki 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)
}
//...
}
Odpowiedź:
trait Pure[P[_]] {
def pure[A](a: => A): P[A]
}
Jeden Pznak podkreślenia w polach po nim oznacza, że jest to konstruktor typu, który przyjmuje jeden typ i zwraca inny typ. Przykłady konstruktorów typu z tego rodzaju: List, Option.
Daj , rodzaj betonu, a to daje , inny rodzaj betonu. Daj i to daje . Itp.ListIntList[Int]ListStringList[String]
Tak więc List, Optionmoże być uznana za funkcje Wysokość Rodzaj liczbę operandów 1. Formalnie mówimy, mają rodzaju * -> *. Gwiazdka oznacza typ.
Teraz Tuple2[_, _]jest konstruktorem typu z rodzajem, (*, *) -> *tzn. Musisz nadać mu dwa typy, aby uzyskać nowy typ.
Ponieważ ich podpisy nie pasują, nie można zastąpić Tuple2za P. To, co musisz zrobić, to częściowo zastosować Tuple2 jeden z jego argumentów, co da nam konstruktor typu z rodzajem * -> *i możemy go zastąpić P.
Niestety Scala nie ma specjalnej składni do częściowego stosowania konstruktorów typów, więc musimy uciekać się do potworności zwanej lambdami typów. (To, co masz w swoim przykładzie). Nazywa się je tak, ponieważ są analogiczne do wyrażeń lambda, które istnieją na poziomie wartości.
Poniższy przykład może pomóc:
// 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>
Edytować:
Więcej równoległych poziomów wartości i typów.
// 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>
W przypadku, który przedstawiłeś, parametr typu Rjest lokalny dla funkcji, Tuple2Purewięc nie możesz go po prostu zdefiniować type PartialTuple2[A] = Tuple2[R, A], ponieważ po prostu nie ma miejsca, w którym możesz umieścić ten synonim.
Aby poradzić sobie z takim przypadkiem, używam następującej sztuczki, która wykorzystuje składowe typu. (Mam nadzieję, że przykład jest oczywisty).
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)]