 
   Notice we started with a range and then we created a stream that is
   meant to multiply each item in the range by 2. At this point, no
-  computation was done yet. Just when `Enum.map/2` is called is that we
-  enumerate each item in the range, multiplying it per 2 and adding 1.
-  We say the functions in `Stream` are lazy and the functions in `Enum`
-  are eager.
-
-  Due to its laziness, streams are useful when working with large collections
-  (or even infinite collections). When chaining many operations with `Enum`,
-  intermediary lists are created, while `Stream` creates a recipe of
-  computations that are executed just at a later moment. Let's see another
+  computation was done yet. Just when `Enum.map/2` is called we
+  enumerate over each item in the range, multiplying it by 2 and adding 1.
+  We say the functions in `Stream` are *lazy* and the functions in `Enum`
+  are *eager*.
+
+  Due to their laziness, streams are useful when working with large 
+  (or even infinite) collections. When chaining many operations with `Enum`,
+  intermediate lists are created, while `Stream` creates a recipe of
+  computations that are executed at a later moment. Let's see another
   example:
 
       1..3 |>

      iex> Enum.map(stream, &1 + 1)
      [3,5,7]

  By simply passing a list (which is an enumerable) as first argument
  to `Stream.map/2`, we have automatically created a stream that will
  multiply the items in the list by 2 on enumeration.



  ## Creating Streams

  There are many functions in Elixir's standard library that return
  streams, some examples are:

  * `IO.stream/1` - Streams input lines, one by one;
  * `URI.query_decoder/1` - Decodes a query string, pair by pair;

  This module also allows us to create streams from any enumerable:
