Lower bound in tour includes dangers

Author: som-snytt

_tour/lower-type-bounds.md

@@ -42,26 +42,40 @@ trait Node[+B] {
   def prepend[U >: B](elem: U): Node[U]
 }
 
-case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
+case class ListNode[+B](head: B, tail: Node[B]) extends Node[B] {
   def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
-  def head: B = h
-  def tail: Node[B] = t
 }
 
-case class Nil[+B]() extends Node[B] {
-  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
+object Nil extends Node[Nothing] {
+  def prepend[U >: Nothing](elem: U): ListNode[U] = ListNode(elem, this)
 }
 ```
 
+We have also simplified `ListNode` to leverage its `case class` fields, and `Nil` to be a singleton object; it is a "node of nothing" because it does not hold an element. The type parameter for `Node` is `B` to suggest we want to store birds at each node.
+
 Now we can do the following:
 ```scala mdoc
 trait Bird
 case class AfricanSwallow() extends Bird
 case class EuropeanSwallow() extends Bird
 
+val africanSwallows: Node[AfricanSwallow] = ListNode[AfricanSwallow](AfricanSwallow(), Nil)
+val swallowsFromAntarctica: Node[Bird] = Nil
 
-val africanSwallowList = ListNode[AfricanSwallow](AfricanSwallow(), Nil())
-val birdList: Node[Bird] = africanSwallowList
-birdList.prepend(EuropeanSwallow())
+// assign swallows to birds
+val birds: Node[Bird] = africanSwallows
+
+// add a swallow to birds
+val moreBirds = birds.prepend(EuropeanSwallow())
+
+// add disparate swallows together to get birds
+val allBirds = africanSwallows.prepend(EuropeanSwallow())
+
+// but this is a mistake! adding a Node to birds widens the type arg too much. -Xlint will warn!
+val error = moreBirds.prepend(swallowsFromAntarctica)
 ```
-The `Node[Bird]` can be assigned the `africanSwallowList` but then accept `EuropeanSwallow`s.
+The covariant type parameter allows `birds` to get the value of `africanSwallows`.
+
+The type bound on the type parameter for `prepend` allows adding different varieties of swallows and getting a wider type: instead of `Node[AfricanSwallow]`, we get a `Node[Bird]`.
+
+The canary in the coal mine is `-Xlint`, which will warn if the type arg is widened too much.