 
   ## 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


  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 first.

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

  example, is only available inside the `User` module and nowhere else.
  You can find more information in `Kernel.defrecordp/2` docs.

  In general, though, records are used as part of a module's public
  interface. For such use cases, Elixir provides record modules.

  ## defrecord

