Revert "Merge pull request #3 from carlosgaldino/master"

Reason: Seems like github doesn't updated the pygment to GitHub Pages

This reverts commit c770777, reversing
changes made to 6ab2bde.

Author: Rafael Mendonça França

_includes/top.html

@@ -5,7 +5,6 @@
   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
 	<title>{{ page.title }}</title>
   <link rel="stylesheet" type="text/css" href="/css/style.css">
-  <link rel="stylesheet" type="text/css" href="/css/syntax.css">
 	<link rel="shortcut icon" href="/images/logo/drop.png">
   <meta name="viewport" content="width=device-width,initial-scale=1">
   <link rel="stylesheet" id="font-bitter-css" href="http://fonts.googleapis.com/css?family=Bitter&amp;ver=1" type="text/css" media="screen">
@@ -50,4 +49,4 @@ <h2 id="site-description">
       </h2>
 		</div>
 
-		<div id="main">
+		<div id="main">

css/syntax.css

@@ -31,14 +31,12 @@ If you don't use any of the distributions above, don't worry! Continue reading f
 
 You can download and compile Elixir in few steps:
 
-{% highlight console %}
-$ git clone https://github.com/elixir-lang/elixir.git
-$ cd elixir
-$ make test
+    $ git clone https://github.com/elixir-lang/elixir.git
+    $ cd elixir
+    $ make test
 
-$ bin/elixir -v
-Elixir 0.4.0.dev
-{% endhighlight %}
+    $ bin/elixir -v
+    Elixir 0.4.0.dev
 
 If tests pass, you are ready to go. Otherwise, feel free to open an issue [in the issues tracker on Github](https://github.com/elixir-lang/elixir).
 
@@ -51,110 +49,88 @@ If tests pass, you are ready to go. Otherwise, feel free to open an issue [in th
 
 We can start Elixir interactive mode by running `bin/iex` in the same directory you compiled Elixir or by simply running `iex` if you installed it from a distribution. In interactive mode, we can type any Elixir expression. Let's warm up with some basic arithmetic expressions:
 
-{% highlight iex %}
-iex> 1 + 1
-2
-iex> 10 - 5
-5
-iex> 10 / 2
-5.0
-{% endhighlight %}
+    iex> 1 + 1
+    2
+    iex> 10 - 5
+    5
+    iex> 10 / 2
+    5.0
 
 Notice `10 / 2` returned a float `5.0` instead of an integer. This is expected, in Elixir the operator `/` always returns a float. In case you want to do integer division or get the division remainder, you can invoke the `div` and `rem` functions:
 
-{% highlight iex %}
-iex> div(10, 2)
-5
-iex> div 10, 2
-5
-iex> rem 10, 3
-1
-{% endhighlight %}
+    iex> div(10, 2)
+    5
+    iex> div 10, 2
+    5
+    iex> rem 10, 3
+    1
 
 In the example above, we called two functions called `div` and `rem`. Notice that parenthesis are not required in order to invoke a function. We are going to discuss more about it later. Let's move forward and see which other data types we have in Elixir:
 
 ## 1.3 Basic types
 
 Some basic types are:
 
-{% highlight iex %}
-iex> 1          # integer
-iex> 1.0        # float
-iex> :atom      # atom / symbol
-iex> {1,2,3}    # tuple
-iex> [1,2,3]    # list
-{% endhighlight %}
+    iex> 1          # integer
+    iex> 1.0        # float
+    iex> :atom      # atom / symbol
+    iex> {1,2,3}    # tuple
+    iex> [1,2,3]    # list
 
 Elixir also provides functions (note the dot between the variable and arguments when calling a function):
 
-{% highlight iex %}
-# function
-iex> x = fn(a, b) -> a + b end
-#Fun<erl_eval.12.111823515>
-iex> x.(1, 2)
-3
-{% endhighlight %}
+    # function
+    iex> x = fn(a, b) -> a + b end
+    #Fun<erl_eval.12.111823515>
+    iex> x.(1, 2)
+    3
 
 And double-quoted strings:
 
-{% highlight iex %}
-iex> "string"
-"string"
-{% endhighlight %}
+    iex> "string"
+    "string"
 
 Strings in Elixir are UTF-8 binaries delimited by double quotes. A single-quoted string in Elixir is called a char list and is simply a list of characters:
 
-{% highlight iex %}
-iex> 'string'
-'string'
-{% endhighlight %}
+    iex> 'string'
+    'string'
 
 There is also string interpolation:
 
-{% highlight iex %}
-iex> name = "world"
-iex> "hello #{name}"
-"hello world"
-{% endhighlight %}
+	iex> name = "world"
+	iex> "hello #{name}"
+	"hello world"
 
 We can use the `is_binary` and `is_list` helpers to detect if a given string is a binary (double-quoted) or a list (single-quoted):
 
-{% highlight iex %}
-iex> is_binary "string"
-true
-iex> is_list "string"
-false
+    iex> is_binary "string"
+    true
+    iex> is_list "string"
+    false
 
-iex> is_binary 'string'
-false
-iex> is_list 'string'
-true
-{% endhighlight %}
+    iex> is_binary 'string'
+    false
+    iex> is_list 'string'
+    true
 
 Although they represent the same thing, double-quoted and single-quoted strings are different and best suited for different scenarios:
 
-{% highlight iex %}
-iex> "string" == 'string'
-false
-{% endhighlight %}
+    iex> "string" == 'string'
+    false
 
 Most of the cases, developers should use double-quoted strings as their representation is more compact. We are going to discuss this subject with more detail in the next chapter.
 
 Elixir also provides `true` and `false` as booleans:
 
-{% highlight iex %}
-iex> true
-true
-iex> is_boolean false
-true
-{% endhighlight %}
+    iex> true
+    true
+    iex> is_boolean false
+    true
 
 Booleans are represented internally as atoms:
 
-{% highlight iex %}
-iex> is_atom(true)
-true
-{% endhighlight %}
+    iex> is_atom(true)
+    true
 
 Elixir also provides Port, References and PIDs as data types (usually used in process communication) but they are out of the scope of a getting started tutorial. For now, let's take a look at the basic operators in Elixir before we move on to the next chapter.
 
@@ -164,88 +140,70 @@ As we saw earlier, Elixir provides `+`, `-`, `*`, `/` as arithmetic operators.
 
 Elixir also provides `++` and `--` to manipulate lists:
 
-{% highlight iex %}
-iex> [1,2,3] ++ [4,5,6]
-[1,2,3,4,5,6]
-iex> [1,2,3] -- [2]
-[1,3]
-{% endhighlight %}
+    iex> [1,2,3] ++ [4,5,6]
+    [1,2,3,4,5,6]
+    iex> [1,2,3] -- [2]
+    [1,3]
 
 Since single-quoted strings are lists, we can also use `++` and `--` as operators to manipulate them:
 
-{% highlight iex %}
-iex> 'some' ++ ' example'
-'some example'
-iex> 'some' -- 'oe'
-'sm'
-{% endhighlight %}
+    iex> 'some' ++ ' example'
+    'some example'
+    iex> 'some' -- 'oe'
+    'sm'
 
 Notice that `++` and `--` cannot be used to manipulate double quoted strings, as they are binaries. That said, string concatenation is done via `<>`:
 
-{% highlight iex %}
-iex> "foo" <> "bar"
-"foobar"
-{% endhighlight %}
+    iex> "foo" <> "bar"
+    "foobar"
 
 Elixir also provides three boolean operators: `or`, `and` and `not`. Those operators are strict in the sense those operators expects only booleans (true or false) as arguments:
 
-{% highlight iex %}
-iex> true and true
-true
-iex> false or is_atom(:example)
-true
-{% endhighlight %}
+    iex> true and true
+    true
+    iex> false or is_atom(:example)
+    true
 
 Giving a non-boolean as argument will raise an exception:
 
-{% highlight iex %}
-iex> 1 and true
-** (::ArgumentError) argument error
-{% endhighlight %}
+    iex> 1 and true
+    ** (::ArgumentError) argument error
 
 `or` and `and` are short-circuit operators. They just execute the right side in case the left side is not enough to determine the result:
 
-{% highlight iex %}
-iex> false and error("This error will never be raised")
-false
+    iex> false and error("This error will never be raised")
+    false
 
-iex> true or error("This error will never be raised")
-true
-{% endhighlight %}
+    iex> true or error("This error will never be raised")
+    true
 
 > Note: If you are an Erlang developer, `and` and `or` in Elixir actually map to the `andalso` and `orelse` operators in Erlang.
 
 Elixir also provides `==`, `!=`, `===`, `!===`, `<=`, `>=`, `<` and `>` as comparison operators:
 
-{% highlight iex %}
-iex> 1 == 1
-true
-iex> 1 != 2
-true
-iex> 1 < 2
-true
-{% endhighlight %}
+    iex> 1 == 1
+    true
+    iex> 1 != 2
+    true
+    iex> 1 < 2
+    true
 
 The difference between `==` and `===` is that the latter is more strict when comparing integers and floats:
 
-{% highlight iex %}
-iex> 1 == 1.0
-true
-iex> 1 === 1.0
-false
-{% endhighlight %}
+    iex> 1 == 1.0
+    true
+    iex> 1 === 1.0
+    false
 
 In Elixir, we can compare two different data types:
 
-{% highlight iex %}
-iex> 1 < :atom
-true
-{% endhighlight %}
+    iex> 1 < :atom
+    true
 
 The reason we can compare different data types is for pragmatism. Sorting algorithms don't need to worry about different data types in order to sort. The overall sorting order is defined below:
 
     number < atom < reference < functions < port < pid < tuple < list < bit string
 
 You actually don't need to memorize this ordering, it is important just to know an order exists.
 
-Well, that is it for the introduction. In the next chapter, we are going to discuss some basic functions, data types conversions and a bit of control-flow.
+Well, that is it for the introduction. In the next chapter, we are going to discuss some basic functions, data types conversions and a bit of control-flow.