Cannot figure out what =:=[A,B] stands for [duplicate]

This question already has answers here: Closed 11开发者_开发技巧 years ago.

Possible Duplicate:

What do <:<, <%<, and =:= mean in Scala 2.8, and where are they documented?

I don't understand what the =:=[A,B] stands for and how it can be useful. I've done some research but it's difficult to search something which has no alphanum chars in it. Can someone help me with a real example ?

---

From Scala 2.8 onwards parameterized types have been afforded even more constraint capabilities via generalized type constraint classes. These classes enable further specialisation in methods, and complement context bounds, as follows:

A =:= B asserts that A and B must be the equal

A <:< B asserts that A must be a subtype of B

A sample usage of these classes would be to enable a specialization for addition of numeric elements in a collection, or for bespoke print formatting, or to allow for customized liability calculations on specific bet or fund types in a traders portfolio. For example:

case class PrintFormatter[T](item : T) {
def formatString(implicit evidence: T =:= String) = { // Will only work for String PrintFormatters
     println("STRING specialised printformatting...")
}
    def formatPrimitive(implicit evidence: T <:< AnyVal) = { // Will only work for Primitive PrintFormatters
println("WRAPPED PRIMITIVE specialised printformatting...")
}
}

val stringPrintFormatter = PrintFormatter("String to format...")
stringPrintFormatter formatString
// stringPrintFormatter formatPrimitive // Will not compile due to type mismatch

val intPrintFormatter = PrintFormatter(123)
intPrintFormatter formatPrimitive
// intPrintFormatter formatString // Will not compile due to type mismatch

You can find a whole short course about Scala types here: http://scalabound.org/?p=323

---

The =:=[A,B] class is evidence for A and B beeing the same class. See e.g. http://apocalisp.wordpress.com/2010/06/10/type-level-programming-in-scala-part-2-implicitly-and/ for an explanation.

It's really hard to find some examples. Here is a little bit code:

• http://scala-programming-language.1934581.n4.nabble.com/Type-Level-Programming-Problem-td3207141.html
• http://michid.wordpress.com/2010/06/18/type-level-programming-equality/

---

The best thing to find out is to look at the source of Predef. There you find this:

object =:= {
  implicit def tpEquals[A]: A =:= A = new (A =:= A) {def apply(x: A) = x}
}

Thus an object of type A =:= B is only available implicitly if A and B are the same type.