 
   ## Runtime access
 
-  All the functionality discussed aboved happens at compilation time.
+  All the functionality discussed above happens at compilation time.
   This means that both `user(user, age: 26)` and `User[user, age: 26]`
-  discussed previously will be a simple tuple operation at compilation
-  time.
+  will be transformed into a simple tuple operation at compile time.
 
   However, there are some situations where we want to set or update
-  fields  dynamically and `defrecord` (and `defrecord` only) supports
+  fields dynamically. `defrecord` (and `defrecord` only) supports
   it out of the box:
 
       defrecord User, name: "José", age: 25
 
       opts = [name: "Hello"]
       user = User.new(opts)
-      #=> { User, "Hello", 25 }
+      #=> User[name: "Hello", age: 25]
       user.update(age: 26)
-      #=> { User, "Hello", 26 }
+      #=> User[name: "Hello", age: 26]
 
   All the calls above are happening at runtime. It gives Elixir
   records a lot of flexibility at the cost of performance since

  element and encapsulate the generation and manipulation of
  such tuples. Many functionality provided by this module happens
  at compilation time, meaning they don't add any overhead while
  considerably improving the quality of our software.

  For those reasons, Records are frequently used in Elixir and
  they are also very useful when used with Protocols. This module


  The macro name is replaced by the module name and the parenthesis
  are replaced by brackets. When the shortcut syntax is used, there
  is no need to import the record.

  Before we sum up the differences in between `defrecord` and
  `defrecordp`, there is one last functionality introduced by
