       IO.puts(welcome_message("Meg", "meg", "example.com"))
       #=> "Welcome Meg, your email is: meg@example.com"
 
-  Every time you concatenate binaries and use interpolation (`#{}`) you are making
+  Every time you concatenate binaries or use interpolation (`#{}`) you are making
   copies of those binaries. However, in many cases you don't need the complete
-  binary while you manipulate it, but only at the end to print it out or send it
-  somewhere. In such cases, you can construct the binary by creating IO data and
-  then convert the final piece of IO data to a binary through `iodata_to_binary/1`:
+  binary while you create it, but only at the end to print it out or send it
+  somewhere. In such cases, you can construct the binary by creating IO data:
 
       def email(username, domain) do
         [username, ?@, domain]

      [?h, "el", ["l", [?o]]]

  The built-in `t:iodata/0` type is defined in terms of `t:iolist/0`. An IO list is
  the same as IO data, but it doesn't allow for a binary at the top level (that is,
  a binary is not an IO list but it is valid IO data).

  ### Use cases for IO data


        ["Welcome ", name, ", your email is: ", email(username, domain)]
      end

      IO.puts(welcome_message("Meg", "meg", "example.com"))
      #=> "Welcome Meg, your email is: meg@example.com"

  Building IO data is cheaper than concatenating binaries. Concatenating multiple
  pieces of IO data just means putting them together inside a list since IO data
  can be arbitrarily nested, and that's a cheap and efficient operation. Most of
  the IO-based APIs, such as `:gen_tcp`, `IO`, etc, receive IO data and write it
  to the socket directly without converting it to binary.

  One drawback of IO data is that you can't do things like pattern match on the
  first part of a piece of IO data like you can with a binary, because you usually
  don't know the shape of the IO data. In those cases, you may need to convert it
  to a binary by calling `iodata_to_binary/1`, which is reasonably efficient
  since it's implemented natively in C. Other functionality, like computing the
  length of IO data, can be computed directly on the iodata by calling `iodata_length/1`.

  ### Chardata

