backticks and cases corrected

Author: eksperimental

_posts/2013-12-11-elixir-s-new-continuable-enumerators.markdown

@@ -89,7 +89,7 @@ the basis of a zip function. Without interleaving you cannot implement
 
 The underlying problem, in both cases, is that the producer is fully in control.
 The producer simply pushes out as many elements to the consumer as it wants and
-then says "I'm done". There's no way aside from `throw`/`raise` for a consumer
+then says "I'm done". There's no way aside from `throw/raise` for a consumer
 to tell a producer "stop producing". There is definitely no way to tell a
 producer "stop for now but be prepared to continue where you left off later".
 

getting-started/alias-require-and-import.markdown

@@ -10,7 +10,7 @@ redirect_from: /getting_started/13.html
 
 In order to facilitate software reuse, Elixir provides three directives. As we are going to see below, they are called directives because they have **lexical scope**.
 
-## alias
+## `alias`
 
 `alias` allows you to set up aliases for any given module name. Imagine our `Math` module uses a special list implementation for doing math specific operations:
 
@@ -59,7 +59,7 @@ end
 
 In the example above, since we are invoking `alias` inside the function `plus/2`, the alias will just be valid inside the function `plus/2`. `minus/2` won't be affected at all.
 
-## require
+## `require`
 
 Elixir provides macros as a mechanism for meta-programming (writing code that generates code).
 
@@ -78,7 +78,7 @@ In Elixir, `Integer.is_odd/1` is defined as a macro so that it can be used as a
 
 In general a module does not need to be required before usage, except if we want to use the macros available in that module. An attempt to call a macro that was not loaded will raise an error. Note that like the `alias` directive, `require` is also lexically scoped. We will talk more about macros in a later chapter.
 
-## import
+## `import`
 
 We use `import` whenever we want to easily access functions or macros from other modules without using the fully-qualified name. For instance, if we want to use the `duplicate/2` function from the `List` module several times, we can simply import it:
 

getting-started/case-cond-and-if.markdown

@@ -10,7 +10,7 @@ redirect_from: /getting_started/5.html
 
 In this chapter, we will learn about the `case`, `cond` and `if` control-flow structures.
 
-## case
+## `case`
 
 `case` allows us to compare a value against many patterns until we find a matching one:
 
@@ -133,7 +133,7 @@ iex> f.(-1, 3)
 
 The number of arguments in each anonymous function clause needs to be the same, otherwise an error is raised.
 
-## cond
+## `cond`
 
 `case` is useful when you need to match against different values. However, in many circumstances, we want to check different conditions and find the first one that evaluates to true. In such cases, one may use `cond`:
 
@@ -174,7 +174,7 @@ iex> cond do
 "1 is considered as true"
 ```
 
-## if and unless
+## `if` and `unless`
 
 Besides `case` and `cond`, Elixir also provides the macros `if/2` and `unless/2` which are useful when you need to check for just one condition:
 
@@ -204,16 +204,16 @@ iex> if nil do
 
 > Note: An interesting note regarding `if/2` and `unless/2` is that they are implemented as macros in the language; they aren't special language constructs as they would be in many languages. You can check the documentation and the source of `if/2` in [the `Kernel` module docs](/docs/stable/elixir/Kernel.html). The `Kernel` module is also where operators like `+/2` and functions like `is_function/2` are defined, all automatically imported and available in your code by default.
 
-## `do`/`end` blocks
+## `do/end` blocks
 
-At this point, we have learned four control structures: `case`, `cond`, `if` and `unless`, and they were all wrapped in `do`/`end` blocks. It happens we could also write `if` as follows:
+At this point, we have learned four control structures: `case`, `cond`, `if` and `unless`, and they were all wrapped in `do/end` blocks. It happens we could also write `if` as follows:
 
 ```iex
 iex> if true, do: 1 + 2
 3
 ```
 
-In Elixir, `do`/`end` blocks are a convenience for passing a group of expressions to `do:`. These are equivalent:
+In Elixir, `do/end` blocks are a convenience for passing a group of expressions to `do:`. These are equivalent:
 
 ```iex
 iex> if true do
@@ -235,7 +235,7 @@ iex> if false, do: :this, else: :that
 :that
 ```
 
-One thing to keep in mind when using `do`/`end` blocks is they are always bound to the outermost function call. For example, the following expression:
+One thing to keep in mind when using `do/end` blocks is they are always bound to the outermost function call. For example, the following expression:
 
 ```iex
 iex> is_number if true do

getting-started/io-and-the-file-system.markdown

@@ -84,7 +84,7 @@ as, in case of an error, `File.read/1` will return `{:error, reason}` and the pa
 
 If you don't want to handle a possible error (i.e., you want it to bubble up), prefer using `File.read!/1`.
 
-## The Path module
+## The `Path` module
 
 The majority of the functions in the `File` module expect paths as arguments. Most commonly, those paths will be regular binaries. The [`Path`](/docs/stable/elixir/Path.html) module provides facilities for working with such paths:
 

getting-started/mix-otp/agent.markdown

@@ -139,7 +139,7 @@ end
 
 You can read more about ExUnit cases in the [`ExUnit.Case` module documentation](/docs/stable/ex_unit/ExUnit.Case.html) and more about callbacks in [`ExUnit.Callbacks` docs](/docs/stable/ex_unit/ExUnit.Callbacks.html).
 
-## Other Agent actions
+## Other agent actions
 
 Besides getting a value and updating the agent state, agents allow us to get a value and update the agent state in one function call via `Agent.get_and_update/2`. Let's implement a `KV.Bucket.delete/2` function that deletes a key from the bucket, returning its current value:
 
@@ -154,9 +154,9 @@ def delete(bucket, key) do
 end
 ```
 
-Now it is your turn to write a test for the functionality above! Also, be sure to explore the documentation for Agents to learn more about them.
+Now it is your turn to write a test for the functionality above! Also, be sure to explore the documentation for agents to learn more about them.
 
-## Client/Server in Agents
+## Client/Server in agents
 
 Before we move on to the next chapter, let's discuss the client/server dichotomy in agents. Let's expand the `delete/2` function we have just implemented:
 

getting-started/mix-otp/genserver.markdown

@@ -245,7 +245,7 @@ Observe that we were able to considerably change the server implementation witho
 
 Finally, different from the other callbacks, we have defined a "catch-all" clause for `handle_info/2` that discards any unknown message. To understand why, let's move on to the next section.
 
-## call, cast or info?
+## `call`, `cast` or `info`?
 
 So far we have used three callbacks: `handle_call/3`, `handle_cast/2` and `handle_info/2`. Deciding when to use each is straightforward:
 

getting-started/mix-otp/supervisor-and-application.markdown

@@ -14,7 +14,7 @@ When things fail, your first reaction may be: "let's rescue those errors". But,
 
 In this chapter, we are going to learn about supervisors and also about applications. We are going to create not one, but two supervisors, and use them to supervise our processes.
 
-## Our first Supervisor
+## Our first supervisor
 
 Creating a supervisor is not much different from creating a GenServer. We are going to define a module named `KV.Supervisor`, which will use the [Supervisor](/docs/stable/elixir/Supervisor.html) behaviour, inside the `lib/kv/supervisor.ex` file:
 

getting-started/processes.markdown

@@ -14,7 +14,7 @@ Elixir's processes should not be confused with operating system processes. Proce
 
 In this chapter, we will learn about the basic constructs for spawning new processes, as well as sending and receiving messages between different processes.
 
-## spawn
+## `spawn`
 
 The basic mechanism for spawning new processes is with the auto-imported `spawn/1` function:
 
@@ -47,7 +47,7 @@ true
 
 Processes get much more interesting when we are able to send and receive messages.
 
-## send and receive
+## `send` and `receive`
 
 We can send messages to a process with `send/2` and receive them with `receive/1`:
 

getting-started/protocols.markdown

@@ -116,9 +116,9 @@ end
 
 If desired, you could come up with your own semantics for a user being blank. Not only that, you could use structs to build more robust data types, like queues, and implement all relevant protocols, such as `Enumerable` and possibly `Blank`, for this data type.
 
-In many cases though, developers may want to provide a default implementation for structs, as explicitly implementing the protocol for all structs can be tedious. That's when falling back to Any comes in handy.
+In many cases though, developers may want to provide a default implementation for structs, as explicitly implementing the protocol for all structs can be tedious. That's when falling back to `Any` comes in handy.
 
-## Falling back to Any
+## Falling back to `Any`
 
 It may be convenient to provide a default implementation for all types. This can be achieved by setting `@fallback_to_any` to `true` in the protocol definition:
 

getting-started/recursion.markdown

@@ -49,9 +49,9 @@ The second definition matches the pattern and has no guard so it will be execute
 Our `msg` is printed and `print_multiple_times/2` is called again this time with the second argument set to `1`.
 Because `n` is now set to `1`, the guard in our first definition of `print_multiple_times/2` evaluates to true, and we execute this particular definition. The `msg` is printed, and there is nothing left to execute.
 
-We defined `print_multiple_times/2` so that no matter what number is passed as the second argument it either triggers our first definition (known as a "base case") or it triggers our second definition which will ensure that we get exactly one step closer to our base case.
+We defined `print_multiple_times/2` so that no matter what number is passed as the second argument it either triggers our first definition (known as a _base case_) or it triggers our second definition which will ensure that we get exactly one step closer to our base case.
 
-## "Reduce" and "map" algorithms
+## Reduce and map algorithms
 
 Let's now see how we can use the power of recursion to sum a list of numbers:
 
@@ -82,7 +82,7 @@ sum_list [], 6
 
 When the list is empty, it will match the final clause which returns the final result of `6`.
 
-The process of taking a list and "reducing" it down to one value is known as a "reduce" algorithm and is central to functional programming.
+The process of taking a list and _reducing_ it down to one value is known as a _reduce algorithm_ and is central to functional programming.
 
 What if we instead want to double all of the values in our list?
 
@@ -100,7 +100,7 @@ end
 Math.double_each([1, 2, 3]) #=> [2, 4, 6]
 ```
 
-Here we have used recursion to traverse a list doubling each element and returning a new list. The process of taking a list and "mapping" over it is known as a "map" algorithm.
+Here we have used recursion to traverse a list doubling each element and returning a new list. The process of taking a list and _mapping_ over it is known as a _map algorithm_.
 
 Recursion and [tail call](http://en.wikipedia.org/wiki/Tail_call) optimization are an important part of Elixir and are commonly used to create loops. However, when programming in Elixir you will rarely use recursion as above to manipulate lists.
 

getting-started/where-to-go-next.markdown

@@ -28,7 +28,7 @@ Remember that in case of any difficulties, you can always visit the **#elixir-la
 
 Don't forget that you can also check the [source code of Elixir itself](https://github.com/elixir-lang/elixir), which is mostly written in Elixir (mainly the `lib` directory), or [explore Elixir's documentation](/docs.html).
 
-## A Byte of Erlang
+## A byte of Erlang
 
 As the main page of this site puts it: