Add an example of a function that could be improved with implicit parameters.

The signature of maxListUpperBound is similar to that of orderedMergeSort,
it takes a List[T] as its argument, and specifies via an upper bound that T
must be a subtype of Ordered[T].

As mentioned earlier, one weakness with this approach is that you can’t
use the function with lists whose element type isn't already a subtype
of Ordered. For example, you couldn't use the maxListUpperBound function
to find the maximum of a list of integers, because class Int is not
a subtype of Ordered[Int].

Another, more general way to organize maxListUpperBound would be to require
a separate, second argument, in addition to the List[T] argument: a
function that converts a T to an Ordered[T].
Change a function with an upper bound to use an implicit converter parameter instead.

A more general way to organize maxListUpperBound would be to require
a separate, second argument, in addition to the List[T] argument: a
function that converts a T to an Ordered[T].

This approach is shown here In this example, the second argument,
orderer, is placed in a separate argument list and marked implicit.

The orderer parameter in this example is used to describe the ordering
of Ts. In the body of maxListImpParm, this ordering is used in two
places: a recursive call to maxListImpParm, and an if expression that
checks whether the head of the list is larger than the maximum element
of the rest of the list.

The maxListImpParm function is an example of an implicit parameter
used to provide more information about a type mentioned explicitly
in an earlier parameter list. To be specific, the implicit parameter
orderer, of type T => Ordered[T], provides more information about type
T—in this case, how to order Ts. Type T is mentioned in List[T], the
type of parameter elements, which appears in the earlier parameter list.

Because elements must always be provided explicitly in any invocation
of maxListImpParm, the compiler will know T at compile time, and can
therefore determine whether an implicit definition of type T => Ordered[T]
is in scope. If so, it can pass in the second parameter list, orderer, implicitly.

This pattern is so common that the standard Scala library provides implicit
"orderer" methods for many common types. You could therefore use
this maxListImpParm method with a variety of types:

    scala> maxListImpParm(List(1,5,10,3))
    res9: Int = 10
    scala> maxListImpParm(List(1.5, 5.2, 10.7, 3.14159))
    res10: Double = 10.7
    scala> maxListImpParm(List("one", "two", "three"))
    res11: String = two

In the first case, the compiler inserted an orderer function for Ints;
in the second case, for Doubles; in the third case, for Strings.