Para colocar as coisas em contexto: Esta resposta foi postada originalmente em outro tópico. Você está vendo aqui porque os dois threads foram mesclados. A declaração da pergunta no segmento mencionado foi a seguinte:
Como resolver esta definição de tipo: Pure [({type? [A] = (R, a)}) #?]?
Quais são as razões do uso dessa construção?
Recortado vem da biblioteca 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)
}
//...
}
Responda:
trait Pure[P[_]] {
def pure[A](a: => A): P[A]
}
O sublinhado nas caixas depois Pimplica que é um construtor de tipo pega um tipo e retorna outro tipo. Exemplos de construtores de tipos com este tipo: List, Option.
Dê Listum Int, um tipo concreto, e isso lhe dará List[Int]outro tipo concreto. Dê Listum Stringe dá-lhe List[String]. Etc.
Assim, List, Optionpode ser considerado como funções de nível tipo de aridade 1. Formalmente dizemos, eles têm um tipo * -> *. O asterisco indica um tipo.
Agora Tuple2[_, _]é um construtor de tipos com tipo, (*, *) -> *ou seja, você precisa atribuir dois tipos para obter um novo tipo.
Desde suas assinaturas não corresponderem, você não pode substituir Tuple2para P. O que você precisa fazer é aplicar parcialmente Tuple2 em um de seus argumentos, o que nos dará um construtor de tipo com tipo * -> *, e podemos substituí-lo P.
Infelizmente, Scala não possui sintaxe especial para aplicação parcial de construtores de tipo, e, portanto, temos que recorrer à monstruosidade chamada tipo lambdas. (O que você tem no seu exemplo.) Eles são chamados assim porque são análogos às expressões lambda que existem no nível de valor.
O exemplo a seguir pode ajudar:
// 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>
Editar:
Mais paralelos em nível de valor e nível de tipo.
// 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>
No caso apresentado, o parâmetro type Ré local para funcionar Tuple2Puree, portanto, você não pode simplesmente definir type PartialTuple2[A] = Tuple2[R, A], porque simplesmente não há lugar onde você possa colocar esse sinônimo.
Para lidar com esse caso, use o seguinte truque que faz uso de membros do tipo. (Espero que o exemplo seja auto-explicativo.)
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)]