Merge pull request elixir-lang#448 from eksperimental/getting_started_headings

Getting started headings

Author: josevalim

_includes/bottom.html

@@ -26,7 +26,7 @@
     $(document).ready(function() {
         $('.toc').toc({
           title: '',
-          listType: 'ul',
+          listType: 'ol',
           minimumHeaders: 2,
           headers: 'h2, h3, h4, h5, h6',
           showSpeed: 0,

_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

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 13 alias, require and import
-guide: 13
-redirect_from: "/getting_started/13.html"
+title: alias, require and import
+redirect_from: /getting_started/13.html
 ---
 
 # {{ page.title }}
@@ -11,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**.
 
-## 13.1 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:
 
@@ -60,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.
 
-## 13.2 require
+## `require`
 
 Elixir provides macros as a mechanism for meta-programming (writing code that generates code).
 
@@ -79,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.
 
-## 13.3 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:
 
@@ -119,7 +118,7 @@ In the example above, the imported `List.duplicate/2` is only visible within tha
 
 Note that `import`ing a module automatically `require`s it.
 
-## 13.4 Aliases
+## Aliases
 
 At this point you may be wondering: what exactly an Elixir alias is and how is it represented?
 
@@ -154,7 +153,7 @@ iex> mod.flatten([1, [2], 3])
 
 We are simply calling the function `flatten` on the atom `:lists`.
 
-## 13.5 Nesting
+## Nesting
 
 Now that we have talked about aliases, we can talk about nesting and how it works in Elixir. Consider the following example:
 

getting-started/basic-operators.markdown

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 3 Basic operators
-guide: 3
-redirect_from: "/getting_started/3.html"
+title: Basic operators
+redirect_from: /getting_started/3.html
 ---
 
 # {{ page.title }}

getting-started/basic-types.markdown

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 2 Basic types
-guide: 2
-redirect_from: "/getting_started/2.html"
+title: Basic types
+redirect_from: /getting_started/2.html
 ---
 
 # {{ page.title }}
@@ -22,7 +21,7 @@ iex> [1, 2, 3]  # list
 iex> {1, 2, 3}  # tuple
 ```
 
-## 2.1 Basic arithmetic
+## Basic arithmetic
 
 Open up `iex`  and type the following expressions:
 
@@ -79,7 +78,7 @@ iex> trunc 3.58
 3
 ```
 
-## 2.2 Booleans
+## Booleans
 
 Elixir supports `true` and `false` as booleans:
 
@@ -105,7 +104,7 @@ You can also use `is_integer/1`, `is_float/1` or `is_number/1` to check, respect
 
 > Note: At any moment you can type `h` in the shell to print information on how to use the shell. The `h` helper can also be used to access documentation for any function. For example, typing `h is_integer/1` is going to print the documentation for the `is_integer/1` function. It also works with operators and other constructs (try `h ==/2`).
 
-## 2.3 Atoms
+## Atoms
 
 Atoms are constants where their name is their own value. Some other languages call these symbols:
 
@@ -127,7 +126,7 @@ iex> is_boolean(:false)
 true
 ```
 
-## 2.4 Strings
+## Strings
 
 Strings in Elixir are inserted between double quotes, and they are encoded in UTF-8:
 
@@ -194,7 +193,7 @@ iex> String.upcase("hellö")
 "HELLÖ"
 ```
 
-## 2.5 Anonymous functions
+## Anonymous functions
 
 Functions are delimited by the keywords `fn` and `end`:
 
@@ -235,7 +234,7 @@ iex> x
 42
 ```
 
-## 2.6 (Linked) Lists
+## (Linked) Lists
 
 Elixir uses square brackets to specify a list of values. Values can be of any type:
 
@@ -292,7 +291,7 @@ false
 
 Single-quotes are char lists, double-quotes are strings. We will talk more about them in the "Binaries, strings and char lists" chapter.
 
-## 2.7 Tuples
+## Tuples
 
 Elixir uses curly brackets to define tuples. Like lists, tuples can hold any value:
 
@@ -329,7 +328,7 @@ Notice that `put_elem/3` returned a new tuple. The original tuple stored in the
 
 By being immutable, Elixir also helps eliminate common cases where concurrent code has race conditions because two different entities are trying to change a data structure at the same time.
 
-## 2.8 Lists or tuples?
+## Lists or tuples?
 
 What is the difference between lists and tuples?
 

getting-started/binaries-strings-and-char-lists.markdown

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 6 Binaries, strings and char lists
-guide: 6
-redirect_from: "/getting_started/6.html"
+title: Binaries, strings and char lists
+redirect_from: /getting_started/6.html
 ---
 
 # {{ page.title }}
@@ -20,7 +19,7 @@ true
 
 In this chapter, we will understand what binaries are, how they associate with strings, and what a single-quoted value, `'like this'`, means in Elixir.
 
-## 6.1 UTF-8 and Unicode
+## UTF-8 and Unicode
 
 A string is a UTF-8 encoded binary. In order to understand exactly what we mean by that, we need to understand the difference between bytes and code points.
 
@@ -59,7 +58,7 @@ You will see that Elixir has excellent support for working with strings. It also
 
 However, strings are just part of the story. If a string is a binary, and we have used the `is_binary/1` function, Elixir must have an underlying type empowering strings. And it does. Let's talk about binaries!
 
-## 6.2 Binaries (and bitstrings)
+## Binaries (and bitstrings)
 
 In Elixir, you can define a binary using `<<>>`:
 
@@ -154,7 +153,7 @@ iex> rest
 
 This finishes our tour of bitstrings, binaries and strings. A string is a UTF-8 encoded binary, and a binary is a bitstring where the number of bits is divisible by 8. Although this shows the flexibility Elixir provides to work with bits and bytes, 99% of the time you will be working with binaries and using the `is_binary/1` and `byte_size/1` functions.
 
-## 6.3 Char lists
+## Char lists
 
 A char list is nothing more than a list of characters:
 

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

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 5 case, cond and if
-guide: 5
-redirect_from: "/getting_started/5.html"
+title: case, cond and if
+redirect_from: /getting_started/5.html
 ---
 
 # {{ page.title }}
@@ -11,7 +10,7 @@ redirect_from: "/getting_started/5.html"
 
 In this chapter, we will learn about the `case`, `cond` and `if` control-flow structures.
 
-## 5.1 case
+## `case`
 
 `case` allows us to compare a value against many patterns until we find a matching one:
 
@@ -50,7 +49,7 @@ iex> case {1, 2, 3} do
 
 The first clause above will only match when `x` is positive.
 
-## 5.2 Expressions in guard clauses.
+## Expressions in guard clauses
 
 The Erlang Virtual Machine (VM) only allows a limited set of expressions in guards:
 
@@ -134,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.
 
-## 5.3 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`:
 
@@ -175,7 +174,7 @@ iex> cond do
 "1 is considered as true"
 ```
 
-## 5.4 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:
 
@@ -205,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.
 
-## 5.5 `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
@@ -236,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/comprehensions.markdown

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 17 Comprehensions
-guide: 17
-redirect_from: "/getting_started/17.html"
+title: Comprehensions
+redirect_from: /getting_started/17.html
 ---
 
 # {{ page.title }}
@@ -20,7 +19,7 @@ iex> for n <- [1, 2, 3, 4], do: n * n
 
 A comprehension is made of three parts: generators, filters and collectables.
 
-## 17.1 Generators and filters
+## Generators and filters
 
 In the expression above, `n <- [1, 2, 3, 4]` is the **generator**. It is literally generating values to be used in the comprehension. Any enumerable can be passed in the right-hand side of the generator expression:
 
@@ -60,7 +59,7 @@ end
 
 Keep in mind that variable assignments inside the comprehension, be it in generators, filters or inside the block, are not reflected outside of the comprehension.
 
-## 17.2 Bitstring generators
+## Bitstring generators
 
 Bitstring generators are also supported and are very useful when you need to comprehend over bitstring streams. The example below receives a list of pixels from a binary with their respective red, green and blue values and converts them into tuples of three elements each:
 
@@ -72,7 +71,7 @@ iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}
 
 A bitstring generator can be mixed with the "regular" enumerable generators and provides filters as well.
 
-## 17.3 Results other than lists
+## Results other than lists
 
 In the examples above, all the comprehensions returned lists as their result. However, the result of a comprehension can be inserted into different data structures by passing the `:into` option to the comprehension.
 

getting-started/enumerables-and-streams.markdown

@@ -1,15 +1,14 @@
 ---
 layout: getting-started
-title: 10 Enumerables and Streams
-guide: 10
-redirect_from: "/getting_started/10.html"
+title: Enumerables and Streams
+redirect_from: /getting_started/10.html
 ---
 
 # {{ page.title }}
 
 {% include toc.html %}
 
-## 10.1 Enumerables
+## Enumerables
 
 Elixir provides the concept of enumerables and [the `Enum` module](/docs/stable/elixir/Enum.html) to work with them. We have already learned two enumerables: lists and maps.
 
@@ -35,7 +34,7 @@ Since the Enum module was designed to work across different data types, its API
 
 We say the functions in the `Enum` module are polymorphic because they can work with diverse data types. In particular, the functions in the `Enum` module can work with any data type that implements [the `Enumerable` protocol](/docs/stable/elixir/Enumerable.html). We are going to discuss Protocols in a later chapter, for now we are going to move on to a specific kind of enumerable called streams.
 
-## 10.2 Eager vs Lazy
+## Eager vs Lazy
 
 All the functions in the `Enum` module are eager. Many functions expect an enumerable and return a list back:
 
@@ -55,7 +54,7 @@ iex> 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum
 
 The example above has a pipeline of operations. We start with a range and then multiply each element in the range by 3. This first operation will now create and return a list with `100_000` items. Then we keep all odd elements from the list, generating a new list, now with `50_000` items, and then we sum all entries.
 
-### 10.2.1 The pipe operator
+### The pipe operator
 
 The `|>` symbol used in the snippet above is the **pipe operator**: it simply takes the output from the expression on its left side and passes it as the input to the function call on its right side. It's similar to the Unix `|` operator.  Its purpose is to highlight the flow of data being transformed by a series of functions. To see how it can make the code cleaner, have a look at the example above rewritten without using the `|>` operator:
 
@@ -66,7 +65,7 @@ iex> Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?))
 
 Find more about the pipe operator [by reading its documentation](http://elixir-lang.org/docs/stable/elixir/Kernel.html#|>/2).
 
-## 10.3 Streams
+## Streams
 
 As an alternative to `Enum`, Elixir provides [the `Stream` module](/docs/stable/elixir/Stream.html) which supports lazy operations:
 

getting-started/introduction.markdown

@@ -1,8 +1,7 @@
 ---
 layout: getting-started
-title: 1 Introduction
-guide: 1
-redirect_from: "/getting_started/1.html"
+title: Introduction
+redirect_from: /getting_started/1.html
 ---
 
 # {{ page.title }}
@@ -22,11 +21,11 @@ Let's get started!
 
 > If you find any errors in the tutorial or on the website, [please report a bug or send a pull request to our issue tracker](https://github.com/elixir-lang/elixir-lang.github.com). If you suspect it is a language bug, [please let us know in the language issue tracker](https://github.com/elixir-lang/elixir/issues).
 
-## 1.1 Installation
+## Installation
 
 If you still haven't installed Elixir, run to our [installation page](/install.html). Once you are done, you can run `elixir -v` to get the current Elixir version.
 
-## 1.2 Interactive mode
+## Interactive mode
 
 When you install Elixir, you will have three new executables: `iex`, `elixir` and `elixirc`. If you compiled Elixir from source or are using a packaged version, you can find these inside the `bin` directory.
 
@@ -43,7 +42,7 @@ iex> "hello" <> " world"
 
 It seems we are ready to go! We will use the interactive shell quite a lot in the next chapters to get a bit more familiar with the language constructs and basic types, starting in the next chapter.
 
-## 1.3 Running scripts
+## Running scripts
 
 After getting familiar with the basics of the language you may want to try writing simple programs. This can be accomplished by putting Elixir code into a file and executing it with `elixir`: