Fix some minor typos in chapter 3.3 (freechipsproject#155)

Author: wunderabt

3.3_higher-order_functions.ipynb

@@ -90,22 +90,22 @@
     "\n",
     "## Different ways of specifying functions\n",
     "You may have noticed that there were two ways of specifying functions in the examples above:\n",
-    "- For functions where each argument is referred to exactly once, you *may* be able to use an underscore (`_`) to refer to each argument. In the example above, the `reduce` argument function took two arguments and could be specified as `_ + _`. While convenient, this is subject to an additional set of arcane rules, so if it does't work, try:\n",
+    "- For functions where each argument is referred to exactly once, you *may* be able to use an underscore (`_`) to refer to each argument. In the example above, the `reduce` argument function took two arguments and could be specified as `_ + _`. While convenient, this is subject to an additional set of arcane rules, so if it doesn't work, try:\n",
     "- Specifying the inputs argument list explicitly. The reduce could have been explicitly written as `(a, b) => a + b`, with the general form of putting the argument list in parentheses, followed by `=>`, followed by the function body referring to those arguments.\n",
     "- When tuple unpacking is needed, using a `case` statement, as in `case (a, b) => a * b`. That takes a single argument, a tuple of two elements, and unpacks it into variables `a` and `b`, which can then be used in the function body.\n",
     "\n",
     "## Practice in Scala\n",
     "In the last module, we've seen major classes in the Scala Collections API, like `List`s.\n",
     "These higher-order functions are part of these APIs - and in fact, the above example uses the `map` and `reduce` API on `List`s.\n",
     "In this section, we'll familiarize ourselves with these methods through examples and exercises.\n",
-    "In these examples, we'll operate on Scala numbers (`Int`s) for the sake of simpliciy and clarify, but because Chisel operators behave similarly, the concepts should generalize.\n",
+    "In these examples, we'll operate on Scala numbers (`Int`s) for the sake of simplicity and clarity, but because Chisel operators behave similarly, the concepts should generalize.\n",
     "\n",
     "<span style=\"color:blue\">**Example: Map**</span><br>\n",
     "`List[A].map` has type signature `map[B](f: (A) ⇒ B): List[B]`. You'll learn more about types in a later module. For now, think of types A and B as `Int`s or `UInt`s, meaning they could be software or hardware types.\n",
     "\n",
     "In plain English, it takes an argument of type `(f: (A) ⇒ B)`, or a function that takes one argument of type `A` (the same type as the element of the input List) and returns a value of type `B` (which can be anything). `map` then returns a new list of type `B` (the return type of the argument function).\n",
     "\n",
-    "As we've already explained the behavior of List in the FIR explanation, let's get straight into the examples and exercises:"
+    "As we've already explained the behavior of List in the FIR example, let's get straight into the examples and exercises:"
    ]
   },
   {
@@ -158,9 +158,9 @@
     "It takes no arguments, but returns a list where each element is a tuple of the original elements, and the index (with the first one being zero).\n",
     "So `List(\"a\", \"b\", \"c\", \"d\").zipWithIndex` would return `List((\"a\", 0), (\"b\", 1), (\"c\", 2), (\"d\", 3))`\n",
     "\n",
-    "This is useful when then element index is needed in some operation.\n",
+    "This is useful when the element index is needed in some operation.\n",
     "\n",
-    "Since this is a pretty straightforward, we'll just have some examples:"
+    "Since this is pretty straightforward, we'll just have some examples:"
    ]
   },
   {
@@ -401,4 +401,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
+}