implicits

The first example successfully finds the implicit conversion to the method foo(String) , however as soon as I add a type parameter (see fails ) the compiles doesn't resolve it anymore: object works { class A { def foo(): String = ??? } implicit class PimpedA(a: A) { def foo(i: String): String = ??? } val a = new A() a.foo("test") //compiles } object fails { //same as `works`, but adds type parameter class A { def foo[T](): String = ??? } implicit class PimpedA(a: A) { def foo[T](i: String): String = ??? } val a = new A() PimpedA(a).foo("test") // compiles a.foo("test") // error: too many

I was messing around with Scala 2.8 for fun and trying to define a pimp which adds an "as" method to type constructors, allowing to convert from one functor to another (please overlook the fact that I'm not necessarily dealing with functors here). So for instance, you could use it like this: val array:Array[T] val list:List[T] = array.as[List] So here's what I tried to do: object Test { abstract class NatTrans[F[_], G[_]] { def convert[T](f:F[T]):G[T] } implicit def array2List:NatTrans[Array, List] = new NatTrans[Array, List] { def convert[T](a:Array[T]) = a.toList } // this next part gets

While trying to find a solution to another question ( [1] ) I came across a diverging implicit expansion error. I'm looking for an explanation about what this means Here's the use case: scala> implicit def ordering[T](implicit conv: T => Ordered[T], res: Ordering[Ordered[T]]) = Ordering.by(conv) ordering: [T](implicit conv: (T) => Ordered[T],implicit res: Ordering[Ordered[T]])scala.math.Ordering[T] scala> def foo[T <% Ordered[T]](s : Seq[T]) = s.sorted <console>:6: error: diverging implicit expansion for type Ordering[T] starting with method ordering in object $iw def foo[T <% Ordered[T]](s :

Suppose I've got a type class that proves that all the types in a Shapeless coproduct are singleton types: import shapeless._ trait AllSingletons[A, C <: Coproduct] { def values: List[A] } object AllSingletons { implicit def cnilSingletons[A]: AllSingletons[A, CNil] = new AllSingletons[A, CNil] { def values = Nil } implicit def coproductSingletons[A, H <: A, T <: Coproduct](implicit tsc: AllSingletons[A, T], witness: Witness.Aux[H] ): AllSingletons[A, H :+: T] = new AllSingletons[A, H :+: T] { def values = witness.value :: tsc.values } } We can show that it works with a simple ADT: sealed

I have seen a function named implicitly used in Scala examples. What is it, and how is it used? Example here : scala> sealed trait Foo[T] { def apply(list : List[T]) : Unit }; object Foo { | implicit def stringImpl = new Foo[String] { | def apply(list : List[String]) = println("String") | } | implicit def intImpl = new Foo[Int] { | def apply(list : List[Int]) = println("Int") | } | } ; def foo[A : Foo](x : List[A]) = implicitly[Foo[A]].apply(x) defined trait Foo defined module Foo foo: [A](x: List[A])(implicit evidence$1: Foo[A])Unit scala> foo(1) <console>:8: error: type mismatch; found : Int