Use a consistent style on all blockquotes

Author: alvinj

Diff for: _overviews/scala3-book/collections-classes.md

@@ -63,7 +63,7 @@ As shown, `Map` and `Set` come in both immutable and mutable versions.
 
 The basics of each type are demonstrated in the following sections.
 
->In Scala, a _buffer_ — such as `ArrayBuffer` and `ListBuffer` — is a sequence that can grow and shrink.
+> In Scala, a _buffer_ — such as `ArrayBuffer` and `ListBuffer` — is a sequence that can grow and shrink.
 
 
 ### A note about immutable collections
@@ -90,9 +90,9 @@ The recommended, general-purpose, “go to” sequential collections for the com
 For example, if you need an immutable, indexed collection, in general you should use a `Vector`.
 Conversely, if you need a mutable, indexed collection, use an `ArrayBuffer`.
 
->`List` and `Vector` are often used when writing code in a functional style.
-`ArrayBuffer` is commonly used when writing code in a mutable style.
-`ListBuffer` is used when you’re mixing styles, such as building a list.
+> `List` and `Vector` are often used when writing code in a functional style.
+> `ArrayBuffer` is commonly used when writing code in a mutable style.
+> `ListBuffer` is used when you’re mixing styles, such as building a list.
 
 The next several sections briefly demonstrate the `List`, `Vector`, and `ArrayBuffer` types.
 
@@ -149,7 +149,7 @@ val c = List(-1, 0) ::: a   // List(-1, 0, 1, 2, 3)
 You can also _append_ elements to a `List`, but because `List` is a singly-linked list, you should generally only prepend elements to it;
 appending elements to it is a relatively slow operation, especially when you work with large sequences.
 
->Tip: If you want to prepend and append elements to an immutable sequence, use `Vector` instead.
+> Tip: If you want to prepend and append elements to an immutable sequence, use `Vector` instead.
 
 Because `List` is a linked-list, you shouldn’t try to access the elements of large lists by their index value.
 For instance, if you have a `List` with one million elements in it, accessing an element like `myList(999_999)` will take a relatively long time, because that request has to traverse all those elements.
@@ -297,7 +297,7 @@ val c = Vector(-1, 0) ++: a   // Vector(-1, 0, 1, 2, 3)
 
 In addition to fast random access and updates, `Vector` provides fast append and prepend times, so you can use these features as desired.
 
->See the [Collections Performance Characteristics](https://docs.scala-lang.org/overviews/collections-2.13/performance-characteristics.html) for performance details about `Vector` and other collections.
+> See the [Collections Performance Characteristics](https://docs.scala-lang.org/overviews/collections-2.13/performance-characteristics.html) for performance details about `Vector` and other collections.
 
 Finally, you use a `Vector` in a `for` loop just like a `List`, `ArrayBuffer`, or any other sequence:
 

Diff for: _overviews/scala3-book/collections-methods.md

@@ -26,8 +26,8 @@ Instead, only some of the most commonly-used methods are shown, including:
 
 The following methods work on all of the sequence types, including `List`, `Vector`, `ArrayBuffer`, etc., but these examples use a `List` unless otherwise specified.
 
->As a very important note, none of the methods on `List` mutate the list.
-They all work in a functional style, meaning that they return a new collection with the modified results.
+> As a very important note, none of the methods on `List` mutate the list.
+> They all work in a functional style, meaning that they return a new collection with the modified results.
 
 
 
@@ -402,7 +402,7 @@ scala> a.reduce(_ * _)
 res1: Int = 24
 ```
 
->An important concept to know about `reduce` is that — as its name implies — it’s used to _reduce_ a collection down to a single value.
+> An important concept to know about `reduce` is that — as its name implies — it’s used to _reduce_ a collection down to a single value.
 
 
 
@@ -411,9 +411,9 @@ res1: Int = 24
 There are literally dozens of additional methods on the Scala collections types that will keep you from ever needing to write another `for` loop.
 See the Reference documentation for more details and examples.
 
->As a final note, if you’re using Java code in a Scala project, you can convert Java collections to Scala collections.
-By doing this you can use those collections in `for` expressions, and can also take advantage of Scala’s functional collections methods.
-See the [Interacting with Java][interacting] section for more details.
+> As a final note, if you’re using Java code in a Scala project, you can convert Java collections to Scala collections.
+> By doing this you can use those collections in `for` expressions, and can also take advantage of Scala’s functional collections methods.
+> See the [Interacting with Java][interacting] section for more details.
 
 
 

Diff for: _overviews/scala3-book/concurrency.md

@@ -16,7 +16,7 @@ When you want to write parallel and concurrent applications in Scala, you _can_
 
 Here’s a description of the Scala `Future` from its Scaladoc:
 
->“A `Future` represents a value which may or may not _currently_ be available, but will be available at some point, or an exception if that value could not be made available.”
+> “A `Future` represents a value which may or may not _currently_ be available, but will be available at some point, or an exception if that value could not be made available.”
 
 To demonstrate what that means, let’s first look at single-threaded programming.
 In the single-threaded world you bind the result of a method call to a variable like this:
@@ -53,9 +53,9 @@ Conversely, if `aShortRunningTask` is created as a `Future`, the `println` state
 In this chapter you’ll see how to use futures, including how to run multiple futures in parallel and combine their results in a `for` expression.
 You’ll also see examples of methods that are used to handle the value in a future once it returns.
 
->When you think about futures, it’s important to know that they’re intended as a one-shot, “Handle this relatively slow computation on some other thread, and call me back with a result when you’re done” construct.
-As a point of contrast, [Akka](https://akka.io) actors are intended to run for a long time and respond to many requests during their lifetime.
-While an actor may live forever, a future is intended to be run only once.
+> When you think about futures, it’s important to know that they’re intended as a one-shot, “Handle this relatively slow computation on some other thread, and call me back with a result when you’re done” construct.
+> As a point of contrast, [Akka](https://akka.io) actors are intended to run for a long time and respond to many requests during their lifetime.
+> While an actor may live forever, a future is intended to be run only once.
 
 
 

Diff for: _overviews/scala3-book/control-structures.md

@@ -389,9 +389,9 @@ In this example the variable `i` is tested against the cases shown.
 If it’s between `0` and `6`, `day` is bound to a string that represents one of the days of the week.
 Otherwise, the catch-all case is represented by the `_` character, and `day` is bound to the string, `"invalid day"`.
 
->When writing simple `match` expressions like this, it’s recommended to use the `@switch` annotation on the variable `i`.
-This annotation provides a compile time warning if the switch can’t be compiled to a `tableswitch` or `lookupswitch`, which are better for performance.
-See the Reference documentation for more details.
+> When writing simple `match` expressions like this, it’s recommended to use the `@switch` annotation on the variable `i`.
+> This annotation provides a compile time warning if the switch can’t be compiled to a `tableswitch` or `lookupswitch`, which are better for performance.
+> See the Reference documentation for more details.
 
 
 ### Using the default value

Diff for: _overviews/scala3-book/domain-modeling-fp.md

@@ -15,7 +15,7 @@ When modeling the world around us with FP, you typically use these Scala constru
 - Case classes
 - Traits
 
->If you’re not familiar with algebraic data types (ADTs) and their generalized version (GADTs), you may want to read the [Algebraic Data Types][adts] section before reading this section.
+> If you’re not familiar with algebraic data types (ADTs) and their generalized version (GADTs), you may want to read the [Algebraic Data Types][adts] section before reading this section.
 
 
 
@@ -42,7 +42,7 @@ An FP design is implemented in a similar way:
 - You describe operations that work on those values (your functions)
 
 > As we will see, reasoning about programs in this style is quite different from the object-oriented programming.
-Data in FP simply **is**:
+> Data in FP simply **is**:
 > Separating functionality from your data let's you inspect your data without having to worry about behavior.
 
 In this chapter we’ll model the data and operations for a “pizza” in a pizza store.
@@ -175,7 +175,7 @@ def crustPrice(s: CrustSize, t: CrustType): Double =
 To compute the price of the crust we simultaneously pattern match on both the size and the type of the crust.
 
 > An important point about all functions shown above is that they are *pure functions*: they do not mutate any data or have other side-effects (like throwing exceptions or writing to a file).
-All they do is simply receive values and compute the result.
+> All they do is simply receive values and compute the result.
 
 ## How to Organize Functionality
 When implementing the `pizzaPrice` function above, we did not say _where_ we would define it.
@@ -195,7 +195,7 @@ These different solutions are shown in the remainder of this section.
 
 A first approach is to define the behavior — the functions — in a companion object.
 
->As discussed in the Domain Modeling [Tools section][modeling-tools], a _companion object_ is an `object` that has the same name as a class, and is declared in the same file as the class.
+> As discussed in the Domain Modeling [Tools section][modeling-tools], a _companion object_ is an `object` that has the same name as a class, and is declared in the same file as the class.
 
 With this approach, in addition to the enumeration or case class you also define an equally named companion object that contains the behavior.
 
@@ -284,9 +284,9 @@ val p4 = updateCrustSize(p3, Large)
 If that code seems okay, you’ll typically start sketching another API — such as an API for orders — but since we’re only looking at pizzas right now, we’ll stop thinking about interfaces and create a concrete implementation of this interface.
 
 > Notice that this is usually a two-step process.
-In the first step, you sketch the contract of your API as an *interface*.
-In the second step you create a concrete *implementation* of that interface.
-In some cases you’ll end up creating multiple concrete implementations of the base interface.
+> In the first step, you sketch the contract of your API as an *interface*.
+> In the second step you create a concrete *implementation* of that interface.
+> In some cases you’ll end up creating multiple concrete implementations of the base interface.
 
 
 ### Creating a concrete implementation

Diff for: _overviews/scala3-book/domain-modeling-tools.md

@@ -623,8 +623,8 @@ case Teacher(name, whatTheyTeach) =>
 Those patterns work because `Student` and `Teacher` are defined as case classes that have `unapply` methods whose type signature conforms to a certain standard.
 Technically, the specific type of pattern matching shown in these examples is known as a *constructor pattern*.
 
->The Scala standard is that an `unapply` method returns the case class constructor fields in a tuple that’s wrapped in an `Option`.
-The “tuple” part of the solution was shown in the previous lesson.
+> The Scala standard is that an `unapply` method returns the case class constructor fields in a tuple that’s wrapped in an `Option`.
+> The “tuple” part of the solution was shown in the previous lesson.
 
 To show how that code works, create an instance of `Student` and `Teacher`:
 
@@ -643,7 +643,7 @@ scala> getPrintableString(t)
 res1: String = Bob Donnan teaches Mathematics.
 ```
 
->All of this content on `unapply` methods and extractors is a little advanced for an introductory book like this, but because case classes are an important FP topic, it seems better to cover them, rather than skipping over them.
+> All of this content on `unapply` methods and extractors is a little advanced for an introductory book like this, but because case classes are an important FP topic, it seems better to cover them, rather than skipping over them.
 
 #### Add pattern matching to any type with unapply
 

Diff for: _overviews/scala3-book/fp-functional-error-handling.md

@@ -96,8 +96,8 @@ There are two common answers, depending on your needs:
 - Use a `match` expression
 - Use a `for` expression
 
->There are other approaches that can be used.
-See the [Reference documentation][reference] for details on those approaches.
+> There are other approaches that can be used.
+> See the [Reference documentation][reference] for details on those approaches.
 
 
 
@@ -234,8 +234,8 @@ makeInt(x) match
   case None => println("That didn't work.")
 ```
 
->There are several other ways to handle `Option` values.
-See the Reference documentation for more details.
+> There are several other ways to handle `Option` values.
+> See the Reference documentation for more details.
 {% endcomment %}
 
 

Diff for: _overviews/scala3-book/fp-functions-are-values.md

@@ -22,7 +22,7 @@ val lessThanFive = nums.filter(_ < 5)   // List(1,2,3,4)
 
 In those examples, anonymous functions are passed into `map` and `filter`.
 
->Anonymous functions are also known as *lambdas*.
+> Anonymous functions are also known as *lambdas*.
 
 In addition to passing anonymous functions into `filter` and `map`, you can also supply them with *methods*:
 
@@ -37,8 +37,8 @@ val doubles = nums.filter(underFive).map(double)
 
 This ability to treat methods and functions as values is a powerful feature that functional programming languages provide.
 
->Technically, a a function that takes another function as an input parameter is known as a *Higher-Order Function*.
-(If you like humor, as someone once wrote, that’s like saying that a class that takes an instance of another class as a constructor parameter is a Higher-Order Class.)
+> Technically, a a function that takes another function as an input parameter is known as a *Higher-Order Function*.
+> (If you like humor, as someone once wrote, that’s like saying that a class that takes an instance of another class as a constructor parameter is a Higher-Order Class.)
 
 
 

Diff for: _overviews/scala3-book/fp-immutable-values.md

@@ -8,7 +8,6 @@ next-page: fp-pure-functions
 ---
 
 
-
 In pure functional programming, only immutable values are used.
 In Scala this means:
 
@@ -68,8 +67,8 @@ val elton = p.copy(
 
 There are other techniques for working with immutable collections and variables, but hopefully these examples give you a taste of the techniques.
 
->Depending on your needs, you may create enums, traits, or classes instead of `case` classes.
-See the [Data Modeling][modeling] chapter for more details.
+> Depending on your needs, you may create enums, traits, or classes instead of `case` classes.
+> See the [Data Modeling][modeling] chapter for more details.
 
 
 

Diff for: _overviews/scala3-book/fp-pure-functions.md

@@ -8,7 +8,6 @@ next-page: fp-functions-are-values
 ---
 
 
-
 {% comment %}
 TODO: Use someone else’s definition?
 {% endcomment %}
@@ -41,8 +40,8 @@ These `String` methods are also pure functions:
 
 Most methods on the Scala collections classes also work as pure functions, including `drop`, `filter`, `map`, and many more.
 
->In Scala, *functions* and *methods* are almost completely interchangeable, so even though we use the common industry term “pure function,” this term can be used to describe both functions and methods.
-If you’re interested in how methods can be used like functions, see the [Eta Expansion][eta] discussion.
+> In Scala, *functions* and *methods* are almost completely interchangeable, so even though we use the common industry term “pure function,” this term can be used to describe both functions and methods.
+> If you’re interested in how methods can be used like functions, see the [Eta Expansion][eta] discussion.
 
 
 
@@ -52,9 +51,9 @@ Conversely, the following functions are *impure* because they violate the defini
 
 The `foreach` method on collections classes is impure because it’s only used for its side effects, such as printing to STDOUT.
 
->A great hint that `foreach` is impure is that it’s method signature declares that it returns the type `Unit`.
-Because it doesn’t return anything, logically the only reason you ever call it is to achieve some side effect.
-Similarly, *any* method that returns `Unit` is going to be an impure function.
+> A great hint that `foreach` is impure is that it’s method signature declares that it returns the type `Unit`.
+> Because it doesn’t return anything, logically the only reason you ever call it is to achieve some side effect.
+> Similarly, *any* method that returns `Unit` is going to be an impure function.
 
 Date and time related methods like `getDayOfWeek`, `getHour`, and `getMinute` are all impure because their output depends on something other than their input parameters.
 Their results rely on some form of hidden I/O; *hidden inputs,* in these examples.
@@ -74,8 +73,8 @@ In general, impure functions do one or more of these things:
 
 Of course an application isn’t very useful if it can’t read or write to the outside world, so people make this recommendation:
 
->Write the core of your application using pure functions, and then write an impure “wrapper” around that core to interact with the outside world.
-As someone once said, this is like putting a layer of impure icing on top of a pure cake.
+> Write the core of your application using pure functions, and then write an impure “wrapper” around that core to interact with the outside world.
+> As someone once said, this is like putting a layer of impure icing on top of a pure cake.
 
 It’s important to note that there are ways to make impure interactions with the outside world feel more pure.
 For instance, you’ll hear about using an `IO` Monad to deal with input and output.
@@ -110,8 +109,8 @@ If you understand that code, you’ll see that it meets the pure function defini
 
 The first key point of this section is the definition of a pure function:
 
->A *pure function* is a function that depends only on its declared inputs and its internal algorithm to produce its output.
-It does not read any other values from “the outside world” — the world outside of the function’s scope — and it doesn’t modify any values in the outside world.
+> A *pure function* is a function that depends only on its declared inputs and its internal algorithm to produce its output.
+> It does not read any other values from “the outside world” — the world outside of the function’s scope — and it doesn’t modify any values in the outside world.
 
 A second key point is that every real-world application interacts with the outside world.
 Therefore, a simplified way to think about functional programs is that they consist of a core of pure functions that are wrapped with other functions that interact with the outside world.

Diff for: _overviews/scala3-book/fun-hofs.md

@@ -190,8 +190,8 @@ As you can infer from these examples, the general syntax for defining function p
 variableName: (parameterTypes ...) => returnType
 ```
 
->Because functional programming is like creating and combining a series of algebraic equations, it’s common to think about types a *lot* when designing functions and applications.
-You might say that you “think in types.”
+> Because functional programming is like creating and combining a series of algebraic equations, it’s common to think about types a *lot* when designing functions and applications.
+> You might say that you “think in types.”
 
 
 

Diff for: _overviews/scala3-book/fun-write-map-function.md

@@ -14,7 +14,7 @@ Imagine for a moment that the `List` class doesn’t have its own `map` method,
 A good first step when creating functions is to accurately state the problem.
 Focusing only on a `List[Int]`, you state:
 
->I want to write a `map` method that can be used to a function to each element in a `List[Int]` that it’s given, returning the transformed elements as a new list.
+> I want to write a `map` method that can be used to a function to each element in a `List[Int]` that it’s given, returning the transformed elements as a new list.
 
 Given that statement, you start to write the method signature.
 First, you know that you want to accept a function as a parameter, and that function should transform an `Int` into some generic type `A`, so you write: