case class UserName(value: String) extends AnyVal
						case class Email(value: String) extends AnyVal
						case class User(name: UserName, email: Email)
						

						val name  = UserName("John N. Types")
						val email = Email("john@lovesjs.com")
						val newUser = User(email, name) // Yay, compile error!
						

• ✔ Typesafe
• ✔ Speaking types instead of "String"
• ✔ Extensible

Why don't we always do this?

• More typing
• Naming things is hard
• Runtime performance (boxing)

							if(user.name.value.size > 20)
							   println("That's a very long name of yours")
							

Changing types

						val x: String = "hi"
						x.isInstanceOf[String] //true

						val iAmNoString: Any = "hi".asInstanceOf[Any]
						iAmNoString.isInstanceOf[CharSequence] //still true
						iAmNoString.isInstanceOf[String] //still true
						

We can't change the runtime-type!
What about compiletime-types?

						val x1: String = "hi"
						val x2: Any = x1 //works
						val x3: String = x1 //works
						val x4: String = x2 //nope
						//x2 is not of compiletime-type String
						

We made scalac lose types!

Adding types

Can we also add types?

						trait T
						val x: String with T = "hi" //nope
						

Compiler knows that "hi" is not of type T

								trait T
								val x: String with T =
								   "hi".asInstanceOf[String with T]
								x.isInstanceOf[T] //false!
								

We just tagged String with T

...the heck is that good for?

						trait UserName
						trait Email
						case class User(name: String with UserName, email: String with Email)
						

Now, let's construct a user:

						val user = User("user", "email") //Not even close
						

						val name = "John".asInstanceOf[String with UserName]
						val email = "john@type.safe".asInstanceOf[String with Email]
						val user = User(name, email) //Good
						val user = User(email, name) //Nope
						
						

• ✔ Typesafe
• ✔ As fast as primitves
• ✔ Speaking types... but ugly 👎

						object Email {
						   trait EmailTag
						   type Email = String with EmailTag
						   def apply(email: String): Email = email.asInstanceOf[Email]
						   def unapply(email: Email): Option[String] = Some(email)
						}
						//copy&paste for UserName
						

And now...

						case class User(name: UserName, email: Email)
						val user = User(UserName("John"), Email("john@type.safe"))
						user match {
						   case User(UserName("John"), _) => println("Hi John")
						   case User(name, _) => println(s"You aren't John but $name")
						}
						println(user.name.size) // works: 4
						

					val anyList: List[Any] = List(42, Email("g@k.de"), "randstr")

					anyList.foreach {
					   case int: Int        => println(s"found Int: $int")
					   case email: Email    => println(s"found Email: $email")
					// case Email(value)    => println(s"found Email: $email")
					   case string: String  => println(s"found String: $string")
					}
					

					//Output:
					//found Int: 42
					//found String: g@k.de
					//found String: randstr