inline code formatting

Author: MatthijsBlom

source_md/higher-order-functions.md

@@ -235,7 +235,7 @@ ghci> zipWith' (zipWith' (*)) [[1,2,3],[3,5,6],[2,3,4]] [[3,2,2],[3,4,5],[5,4,3]
 ```
 
 As you can see, a single higher order function can be used in very versatile ways.
-Imperative programming usually uses stuff like for loops, while loops, setting something to a variable, checking its state, etc. to achieve some behavior and then wrap it around an interface, like a function.
+Imperative programming usually uses stuff like `for` loops, `while` loops, setting something to a variable, checking its state, etc. to achieve some behavior and then wrap it around an interface, like a function.
 Functional programming uses higher order functions to abstract away common patterns, like examining two lists in pairs and doing something with those pairs or getting a set of solutions and eliminating the ones you don't need.
 
 We'll implement another function that's already in the standard library, called `flip`.
@@ -649,7 +649,7 @@ It kind of makes sense that the right fold has the accumulator on the right, bec
 
 The accumulator value (and hence, the result) of a fold can be of any type.
 It can be a number, a boolean or even a new list.
-We'll be implementing the map function with a right fold.
+We'll be implementing the `map` function with a right fold.
 The accumulator will be a list, we'll be accumulating the mapped list element by element.
 From that, it's obvious that the starting element will be an empty list.
 

source_md/input-and-output.md

@@ -2305,7 +2305,7 @@ main = do toTry `catch` handler1
 Here, `toTry` uses `handler1` as the handler and `thenTryThis` uses `handler2`.
 `launchRockets` isn't a parameter to `catch`, so whichever exceptions it might throw will likely crash our program, unless `launchRockets` uses `catch` internally to handle its own exceptions.
 Of course `toTry`, `thenTryThis` and `launchRockets` are I/O actions that have been glued together using `do` syntax and hypothetically defined somewhere else.
-This is kind of similar to *try-catch* blocks of other languages, where you can surround your whole program in a single *try-catch* or you can use a more fine-grained approach and use different ones in different parts of your code to control what kind of error handling happens where.
+This is kind of similar to `try`--`catch` blocks of other languages, where you can surround your whole program in a single `try`--`catch` or you can use a more fine-grained approach and use different ones in different parts of your code to control what kind of error handling happens where.
 
 Now you know how to deal with I/O exceptions!
 Throwing exceptions from pure code and dealing with them hasn't been covered here, mainly because, like we said, Haskell offers much better ways to indicate errors than reverting to I/O to catch them.