Replace Logarithm example with Duration example

Author: allanrenucci

docs/blog/_posts/2018-11-27-11th-dotty-milestone-release.md

@@ -35,57 +35,54 @@ This is our 11th scheduled release according to our
 Opaque types aliases provide type abstraction without any overhead. Example:
 
 ```scala
-opaque type Logarithm = Double
+opaque type Duration = Long
 ```
 
-This introduces `Logarithm` as a new type, which is implemented as `Double` but is different from
-it. The fact that `Logarithm` is the same as `Double` is only known in the companion object of
-`Logarithm`. Here is a possible companion object:
+This introduces `Duration` as a new type, which is implemented as a `Long` but is different from
+it. The fact that `Duration` is the same as `Long` is only known in the companion object of
+`Duration`. Here is a possible companion object:
 
 ```scala
-object Logarithm {
+object Duration {
 
-  // These are the ways to lift to the logarithm type
-  def apply(d: Double): Logarithm = math.log(d)
+  // These are the ways to lift to the Duration type
+  def fromNanos(duration: Long): Duration = duration
+  def fromSeconds(duration: Long): Duration = duration * 1000000000
 
-  def safe(d: Double): Option[Logarithm] =
-    if (d > 0.0) Some(math.log(d)) else None
-
-  // This is the first way to unlift the logarithm type
-  def exponent(l: Logarithm): Double = l
+  // This is the first way to unlift the Duration type
+  def toNanos(l: Duration): Long = l
 
   // Extension methods define opaque types' public APIs
-  implicit class LogarithmOps(val `this`: Logarithm) extends AnyVal {
-    // This is the second way to unlift the logarithm type
-    def toDouble: Double = math.exp(`this`)
-    def +(that: Logarithm): Logarithm = Logarithm(math.exp(`this`) + math.exp(that))
-    def *(that: Logarithm): Logarithm = Logarithm(`this` + that)
+  implicit class DurationOps(self: Duration) extends AnyVal {
+    // This is the second way to unlift the Duration type
+    def toSeconds: Long = self / 1000000000
+    def + (that: Duration): Duration = self + that
   }
 }
 ```
 
-The companion object contains with the `apply` and `safe` methods ways to convert from doubles to
-`Logarithm` values. It also adds an `exponent` function and a decorator that implements `+` and `*`
-on logarithm values, as well as a conversion `toDouble`. All this is possible because within object
-`Logarithm`, the type `Logarithm` is just an alias of `Double`.
+The companion object contains the `fromNanos` and `fromSeconds` methods that convert from longs to
+`Duration` values. It also adds a `toNanos` function and a decorator that implements `+` on
+duration values, as well as a conversion `toSeconds`. All of this is possible because within object
+`Duration`, the type `Duration` is just an alias of `Long`.
 
-Outside the companion object, `Logarithm` is treated as a new abstract type. So the following
-operations would be valid because they use functionality implemented in the `Logarithm`
+Outside the companion object, `Duration` is treated as a new abstract type. So the following
+operations would be valid because they use functionality implemented in the `Duration`
 object.
 
 ```scala
-  val l = Logarithm(1.0)
-  val l3 = l * l2
-  val l4 = l + l2
+val d1 = Duration.fromNanos(1000L)
+val d2 = Duration.fromSeconds(2L)
+val d3 = d1 + d2
 ```
 
 But the following operations would lead to type errors:
 
 ```scala
-  val d: Double = l       // error: found: Logarithm, required: Double
-  val l2: Logarithm = 1.0 // error: found: Double, required: Logarithm
-  l * 2                   // error: found: Int(2), required: Logarithm
-  l / l2                  // error: `/` is not a member fo Logarithm
+val l: Long = d1      // error: found: Duration, required: Long
+val d: Duration = 3L  // error: found: Long(3L), required: Duration
+d1 + 2L               // error: found: Long(2L), required: Duration
+d1 - d2               // error: `-` is not a member of Duration
 ```
 
 ### Worksheet Mode Support in Visual Studio Code