From b9f5211ffd0d097d4caffc40ced8d280e632f460 Mon Sep 17 00:00:00 2001
From: Janek Bogucki <janekdb@gmail.com>
Date: Mon, 10 Apr 2017 12:08:11 +0100
Subject: Fix == in spec linearization examples

Also

 - Consistify trailing punctuation
 - Use whitespace to group linearization examples
---
 spec/03-types.md                              |  4 ++--
 spec/04-basic-declarations-and-definitions.md |  4 ++--
 spec/06-expressions.md                        | 11 ++++++++---
 spec/07-implicits.md                          |  6 +++---
 4 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/spec/03-types.md b/spec/03-types.md
index d2f41daabf..a3167646ca 100644
--- a/spec/03-types.md
+++ b/spec/03-types.md
@@ -507,7 +507,7 @@ Assume the class definitions
 
 ```scala
 class Ref[T]
-abstract class Outer { type T } .
+abstract class Outer { type T }
 ```
 
 Here are some examples of existential types:
@@ -530,7 +530,7 @@ Ref[_ <: java.lang.Number]
 The type `List[List[_]]` is equivalent to the existential type
 
 ```scala
-List[List[t] forSome { type t }] .
+List[List[t] forSome { type t }]
 ```
 
 ###### Example
diff --git a/spec/04-basic-declarations-and-definitions.md b/spec/04-basic-declarations-and-definitions.md
index c4d3425fff..5e055228f1 100644
--- a/spec/04-basic-declarations-and-definitions.md
+++ b/spec/04-basic-declarations-and-definitions.md
@@ -91,7 +91,7 @@ expands to
 ```scala
 case object Red extends Color
 case object Green extends Color
-case object Blue extends Color .
+case object Blue extends Color
 ```
 -->
 
@@ -144,7 +144,7 @@ value definition `val $p$ = $e$` is expanded as follows:
 val $\$ x$ = $e$ match {case $p$ => ($x_1 , \ldots , x_n$)}
 val $x_1$ = $\$ x$._1
 $\ldots$
-val $x_n$ = $\$ x$._n  .
+val $x_n$ = $\$ x$._n
 ```
 
 Here, $\$ x$ is a fresh name.
diff --git a/spec/06-expressions.md b/spec/06-expressions.md
index 0e84c427f6..9e49dfa199 100644
--- a/spec/06-expressions.md
+++ b/spec/06-expressions.md
@@ -222,9 +222,14 @@ the linearization of class `D` is `{D, B, A, Root}`.
 Then we have:
 
 ```scala
-(new A).superA == "Root",
-                          (new C).superB = "Root", (new C).superC = "B",
-(new D).superA == "Root", (new D).superB = "A",    (new D).superD = "B",
+(new A).superA == "Root"
+
+(new C).superB == "Root"
+(new C).superC == "B"
+
+(new D).superA == "Root"
+(new D).superB == "A"
+(new D).superD == "B"
 ```
 
 Note that the `superB` function returns different results
diff --git a/spec/07-implicits.md b/spec/07-implicits.md
index 662b653f71..b0c8c1da24 100644
--- a/spec/07-implicits.md
+++ b/spec/07-implicits.md
@@ -155,7 +155,7 @@ sort(yss)
 The call above will be completed by passing two nested implicit arguments:
 
 ```scala
-sort(yss)(xs: List[Int] => list2ordered[Int](xs)(int2ordered)) .
+sort(yss)(xs: List[Int] => list2ordered[Int](xs)(int2ordered))
 ```
 
 The possibility of passing implicit arguments to implicit arguments
@@ -218,7 +218,7 @@ which implicit arguments are searched is
 
 ```scala
 List[List[Int]] => Ordered[List[List[Int]]],
-List[Int] => Ordered[List[Int]]
+List[Int] => Ordered[List[Int]],
 Int => Ordered[Int]
 ```
 
@@ -290,7 +290,7 @@ or the call-by-name category).
 Class `scala.Ordered[A]` contains a method
 
 ```scala
-  def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean .
+  def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean
 ```
 
 Assume two lists `xs` and `ys` of type `List[Int]`
-- 
cgit v1.2.3