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

Question

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 ?

Sorry for duplication, but again, it is not possible to search for the string "=:="... — paradigmatic, Jun 21 '11 at 13:08

score 11 · Accepted Answer · answered Jun 21 '11 at 09:35

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

@ninjagecko: `a:A` asserts that the _term_ `a` has the _type_ `A`... it's analogous to the "is an element of" relation (a ∈ A) in set theory. `A <:< B` asserts that the _type_ A is a subtype of the _type_ B, which is analogous to the subset relation (A ⊆ B) in set theory. Just as ⊆ can be defined in terms of ∈, we can interpret `A <:< B` as the proposition, "for all terms `t`, if `t:A`, then `t:B`". — Tom Crockett, Aug 21 '11 at 23:29

Landei · Answer 2 · 2011-06-21T09:39:42.343

4

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:

edited Jun 21 '11 at 09:39

answered Jun 21 '11 at 09:01

Landei

54,104
13
100
195

2

Can you give an example how to use it, please? – ziggystar Jun 21 '11 at 09:03

score 0 · Answer 3 · answered Jun 21 '11 at 10:22

0

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.

answered Jun 21 '11 at 10:22

Kim Stebel

41,826
12
125
142

But that is an object which *uses* the class `=:=[A, A]`. It does not explain what `A =:= A` means. – Debilski Jun 21 '11 at 12:40
It does tell you how the compiler can get an instance of A=:=B implicitly, which is the only thing the class is used for. The class _only_ acts as a witness of the fact that A equals B. – Kim Stebel Jun 21 '11 at 13:10

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

3 Answers3