Steps

1. Define some custom types to model your particular domain

case class Donut(name: String, price: Double, productCode: Option[Long] = None) 
case class Cupcake(name: String) 

2. Use a trait as the contract for a given feature 

As we’ve seen earlier in this chapter, we can use a trait as a contract for a given feature. This strategy is equivalent to using an interface in, say, Java, or C#.NET. That being so, we create a trait UniversalId that defines an abstract method named uuid. Since our intent is to add the uuid method to any given type, the trait accepts a type parameter of T. And, of course, the input parameter for the uuid method is also of type T.

trait UniversalId[T] { 
  def uuid(t: T): String 
} 

3. Create the Companion Object and apply() method for the trait

Next, we create the corresponding Companion Object for that above-mentioned trait - that is, object UniversalId { ... }. When it comes to the apply() method, let’s examine each part one at a time, as it can perhaps feel overwhelming at first sight. Likewise to the trait UniversalId[T] which defines a type parameter, the apply[T] method also exemplifies a type parameter. The return type should be straightforward enough, as it basically needs to match the UniversalId of type T - that is, : UniversalId[T].

The most important bit, however, is that we provide an implicit parameter of type UniversalId[T]. And, that is in fact the actual output of the apply method as denoted by = id, where id is the name for the implicit parameter - that is, implicit id: UniversalId[T]. The implicit parameter is in this spot so as to trigger a search by the compiler for implicit values that match to Universal[T] types, as we illustrate shortly in Step 4.

object UniversalId{
 def apply[T](implicit id: UniversalId[T]): UniversalId[T] = id 
}

4. Create implicit instances for your relevant types

Subsequently, we can create objects, or instances, for the types that will provide the features of trait UniversalId[T]. Most importantly though, these objects, or instances, are labeled with the implicit val keywords. This has the opposite effect to Step 3, where we lift values into the implicit scope, and leave it to the compiler to match to the corresponding UniversalId[T] type. As a reminder, it is best to further annotate implicit values with their corresponding types, such as, implicit val donutId: UniversalId[Donut], and implicit val cupcakeId: UniversalId[Cupcake].

We also lean on the style from the popular cats218 library, and provide a helper function - that is, def instance[T](func: T => String): UniversalId[T] - to reduce boilerplate code when creating the relevant objects, or instances, of trait UniversalId[T]. Moreover, we use a top-level Singleton Object - that is, object instances { } - to act as a closure in order to facilitate import statements, such as, import UniversalId.instances.donutId, or import UniversalId.cupcakeId, or import UniversalId.instances._.

object UniversalId {
	def apply[T](implicit id: UniversalId[T]): UniversalId[T] = id

	object instances {
	  	def instance[T](func: T => String): UniversalId[T] =
	    	new UniversalId[T] {
	    		override def uuid(t: T): String = func(t)
	    }

	    implicit val donutId: UnversalId[Donut] = 
	    	instance(donut => s"${donut.name} - ${donut.name.hashCode}")

	    implicit val cupcakeId: UniversalId[Cupcake] = 
	    	instance(cupcake => s"${cupcake.name} - ${cupcake.name.hashCode}")
	}
}

5. Use an Implicit Class to wire the uuid method from Step 2 

Finally, we make use of an implicit class to expose a def uniqueId method that will trigger the uuid method of trait UniversalId[T]. Most definitely, we could have exposed a similar def uuid method, but you can think of this implicit class as an opportunity to provide a business, or domain, friendly method name that is relevant to your particular application, or use case.

Notice also that the implicit class UniversalIdOps makes use of Context Bound with the syntax [T: UniversalId]. Its role is essentially to enforce that a required implicit value of type UniversalId[T] is in scope. Similar to Step 4 with closure for the instances, we follow the cats library style and provide a top-level Singleton Object - that is, object ops - in order to facilitate import statements, such as, import UniversalId.ops._.

object UniversalId {
	def apply[T](implicit id: UniversalId[T]): UniversalId[T] = id

	object instances {
	  	def instance[T](func: T => String): UniversalId[T] =
	    	new UniversalId[T] {
	    		override def uuid(t: T): String = func(t)
	    }

	    implicit val donutId: UnversalId[Donut] = 
	    	instance(donut => s"${donut.name} - ${donut.name.hashCode}")

	    implicit val cupcakeId: UniversalId[Cupcake] = 
	    	instance(cupcake => s"${cupcake.name} - ${cupcake.name.hashCode}")

		}

		object ops {
			implicit class UniversalIdOps[T: UniversalId](t: T) {
				def uniqueId = UniversalId[T].uuid(t)
			}
		}
}

6. Type Class in action

Using the above Type Class is thereafter very straightforward. You basically need to import the relevant statements, such as, import UniversalId.ops._, and import UniversalId.instances._, in order for the Donut and Cupcake types to be augmented with a uniqueId method.

import UniversalId.ops._ import UniversalId.instances._
val plainDonut = Donut("PlainDonut",1.50)
println(plainDonut.uniqueId)
val cupcake = Cupcake("VanillaCupcake")
println(cupcake.uniqueId)

You should see the following output when you run your Scala application in IntelliJ:

Plain Donut - 1429730572 
Vanilla Cupcake - 414501265