```
//Monoids for sets
implicit def setUnion[A] : Monoid[Set[A]] =
new Monoid[Set[A]] {
override def empty: Set[A] = Set.empty
override def combine(x: Set[A], y: Set[A]): Set[A] =
x ++ y
}
implicit val setUnion= new Monoid[Set[_]] {
override def empty: Set[_] = Set.empty //This compiles even though empty takes a type parameter
override def combine(x: Set[_], y: Set[_]): Set[_] =
x ++ y
}
```

The second implementation is never looked up by the compiler. Why?

The second implementation cannot have a type parameter. Hence I have replaced it with `_`

. But is it the same as the first implementation which uses an`implicit def`

as opposed to an `implicit val`

.