Use john and meg in code samples

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -1414,14 +1414,14 @@ defmodule Kernel do
       iex> inspect [1, 2, 3, 4, 5], limit: 3
       "[1, 2, 3, ...]"
 
-      iex> inspect("josé" <> <<0>>)
-      "<<106, 111, 115, 195, 169, 0>>"
+      iex> inspect("olá" <> <<0>>)
+      "<<111, 108, 195, 161, 0>>"
 
-      iex> inspect("josé" <> <<0>>, binaries: :as_strings)
-      "\"josé\\000\""
+      iex> inspect("olá" <> <<0>>, binaries: :as_strings)
+      "\"olá\\000\""
 
-      iex> inspect("josé", binaries: :as_binaries)
-      "<<106, 111, 115, 195, 169>>"
+      iex> inspect("olá", binaries: :as_binaries)
+      "<<111, 108, 195, 161>>"
 
   Note that the inspect protocol does not necessarily return a valid
   representation of an Elixir term. In such cases, the inspected result
@@ -1457,18 +1457,18 @@ defmodule Kernel do
   ## Example
 
       defmodule User do
-        defstruct name: "jose"
+        defstruct name: "john"
       end
 
       struct(User)
-      #=> %User{name: "jose"}
+      #=> %User{name: "john"}
 
-      opts = [name: "eric"]
+      opts = [name: "meg"]
       user = struct(User, opts)
-      #=> %User{name: "eric"}
+      #=> %User{name: "meg"}
 
       struct(user, unknown: "value")
-      #=> %User{name: "eric"}
+      #=> %User{name: "meg"}
 
   """
   @spec struct(module | map, Enum.t) :: map
@@ -1508,22 +1508,22 @@ defmodule Kernel do
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_in(users, ["josé", :age])
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_in(users, ["john", :age])
       27
 
   In case any of entries in the middle returns `nil`, `nil` will be returned
   as per the Access protocol:
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
       iex> get_in(users, ["unknown", :age])
       nil
 
   When one of the keys is a function, the function is invoked.
   In the example below, we use a function to get all the maps
   inside a list:
 
-      iex> users = [%{name: "josé", age: 27}, %{name: "eric", age: 23}]
+      iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
       iex> all = fn :get, data, next -> Enum.map(data, next) end
       iex> get_in(users, [all, :age])
       [27, 23]
@@ -1560,9 +1560,9 @@ defmodule Kernel do
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users, ["josé", :age], 28)
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users, ["john", :age], 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
   In case any of entries in the middle returns `nil`,
   an error will be raised when trying to access it next.
@@ -1582,9 +1582,9 @@ defmodule Kernel do
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users, ["josé", :age], &(&1 + 1))
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users, ["john", :age], &(&1 + 1))
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
   In case any of entries in the middle returns `nil`,
   an error will be raised when trying to access it next.
@@ -1619,20 +1619,20 @@ defmodule Kernel do
   update it at the same time. For example, it could be used to increase
   the age of a user by one and return the previous age in one pass:
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_and_update_in(users, ["josé", :age], &{&1, &1 + 1})
-      {27, %{"josé" => %{age: 28}, "eric" => %{age: 23}}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_and_update_in(users, ["john", :age], &{&1, &1 + 1})
+      {27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}
 
   When one of the keys is a function, the function is invoked.
   In the example below, we use a function to get and increment all
   ages inside a list:
 
-      iex> users = [%{name: "josé", age: 27}, %{name: "eric", age: 23}]
+      iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
       iex> all = fn :get_and_update, data, next ->
       ...>   Enum.map(data, next) |> List.unzip() |> List.to_tuple()
       ...> end
       iex> get_and_update_in(users, [all, :age], &{&1, &1 + 1})
-      {[27, 23], [%{name: "josé", age: 28}, %{name: "eric", age: 24}]}
+      {[27, 23], [%{name: "john", age: 28}, %{name: "meg", age: 24}]}
 
   If the previous value before invoking the function is nil,
   the function *will* receive `nil` as a value and must handle it
@@ -1670,13 +1670,13 @@ defmodule Kernel do
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users["josé"][:age], 28)
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users["john"][:age], 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users["josé"].age, 28)
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users["john"].age, 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
   """
   defmacro put_in(path, value) do
@@ -1703,13 +1703,13 @@ defmodule Kernel do
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users["josé"][:age], &(&1 + 1))
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users["john"][:age], &(&1 + 1))
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users["josé"].age, &(&1 + 1))
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users["john"].age, &(&1 + 1))
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
   """
   defmacro update_in(path, fun) do
@@ -1735,9 +1735,9 @@ defmodule Kernel do
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_and_update_in(users["josé"].age, &{&1, &1 + 1})
-      {27, %{"josé" => %{age: 28}, "eric" => %{age: 23}}}
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_and_update_in(users["john"].age, &{&1, &1 + 1})
+      {27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}
 
   ## Paths
 
@@ -1752,15 +1752,15 @@ defmodule Kernel do
 
   Here are some valid paths:
 
-      users["josé"][:age]
-      users["josé"].age
-      User.all["josé"].age
-      all_users()["josé"].age
+      users["john"][:age]
+      users["john"].age
+      User.all["john"].age
+      all_users()["john"].age
 
   Here are some invalid ones:
 
       # Does a remote call after the initial value
-      users["josé"].do_something(arg1, arg2)
+      users["john"].do_something(arg1, arg2)
 
       # Does not access any field
       users
@@ -2912,7 +2912,7 @@ defmodule Kernel do
   is used:
 
       defmodule User do
-        defstruct name: "José", age: 25
+        defstruct name: "john", age: 25
         @type t :: %User{name: String.t, age: integer}
       end
 

lib/elixir/lib/kernel/special_forms.ex

@@ -114,15 +114,15 @@ defmodule Kernel.SpecialForms do
 
       defmodule User do
         def __struct__ do
-          %{name: "josé", age: 27}
+          %{name: "john", age: 27}
         end
       end
 
   In practice though, structs are usually defined with the
   `Kernel.defstruct/1` macro:
 
       defmodule User do
-        defstruct name: "josé", age: 27
+        defstruct name: "john", age: 27
       end
 
   Now a struct can be created as follows:
@@ -132,13 +132,13 @@ defmodule Kernel.SpecialForms do
   Underneath a struct is just a map with a `__struct__` field
   pointing to the `User` module:
 
-      %User{} == %{__struct__: User, name: "josé", age: 27}
+      %User{} == %{__struct__: User, name: "john", age: 27}
 
   A struct also validates that the given keys are part of the defined
   struct. The example below will fail because there is no key
   `:full_name` in the `User` struct:
 
-      %User{full_name: "José Valim"}
+      %User{full_name: "john doe"}
 
   Note that a struct specifies a minimum set of keys required
   for operations. Other keys can be added to structs via the
@@ -1174,10 +1174,10 @@ defmodule Kernel.SpecialForms do
   Note generators can also be used to filter as it removes any value
   that doesn't match the left side of `<-`:
 
-      iex> for {:user, name} <- [user: "jose", admin: "john", user: "eric"] do
+      iex> for {:user, name} <- [user: "john", admin: "john", user: "meg"] do
       ...>   String.upcase(name)
       ...> end
-      ["JOSE", "ERIC"]
+      ["JOHN", "MEG"]
 
   Bitstring generators are also supported and are very useful when you
   need to organize bitstring streams:

lib/elixir/lib/record.ex

@@ -4,7 +4,7 @@ defmodule Record do
 
   Records are simply tuples where the first element is an atom:
 
-      iex> Record.record? {User, "jose", 27}
+      iex> Record.record? {User, "john", 27}
       true
 
   This module provides conveniences for working with records at
@@ -29,7 +29,7 @@ defmodule Record do
 
       defmodule MyModule do
         require Record
-        Record.defrecord :user name: "José", age: 25
+        Record.defrecord :user name: "john", age: 25
 
         @type user :: record(:user, name: String.t, age: integer)
         # expands to: `@type user :: {:user, String.t, integer}`
@@ -63,7 +63,7 @@ defmodule Record do
 
   ## Examples
 
-      iex> record = {User, "jose", 27}
+      iex> record = {User, "john", 27}
       iex> Record.record?(record, User)
       true
 
@@ -91,7 +91,7 @@ defmodule Record do
 
   ## Examples
 
-      iex> record = {User, "jose", 27}
+      iex> record = {User, "john", 27}
       iex> Record.record?(record)
       true
       iex> tuple = {}
@@ -126,24 +126,24 @@ defmodule Record do
 
       defmodule User do
         require Record
-        Record.defrecord :user, [name: "José", age: "25"]
+        Record.defrecord :user, [name: "meg", age: "25"]
       end
 
   In the example above, a set of macros named `user` but with different
   arities will be defined to manipulate the underlying record:
 
       # To create records
-      record = user()        #=> {:user, "José", 25}
-      record = user(age: 26) #=> {:user, "José", 26}
+      record = user()        #=> {:user, "meg", 25}
+      record = user(age: 26) #=> {:user, "meg", 26}
 
       # To get a field from the record
-      user(record, :name) #=> "José"
+      user(record, :name) #=> "meg"
 
       # To update the record
-      user(record, age: 26) #=> {:user, "José", 26}
+      user(record, age: 26) #=> {:user, "meg", 26}
 
       # Convert a record to a keyword list
-      user(record) #=> [name: "José", age: 26]
+      user(record) #=> [name: "meg", age: 26]
 
   By default, Elixir uses the record name as the first element of
   the tuple (the tag). But it can be changed to something else: