Fix pages code examples (#15663)

Author: AlexGx

lib/elixir/pages/anti-patterns/macro-anti-patterns.md

@@ -380,9 +380,11 @@ If you really need to define modules dynamically, you can do so via meta-program
 defmodule MyMacro do
   defmacro call_examples(parts) do
     for part <- parts do
+      module = Module.concat(OtherModule, part)
+
       quote do
         # This builds OtherModule.Foo at compile-time
-        OtherModule.unquote(part).example()
+        unquote(module).example()
       end
     end
   end

lib/elixir/pages/anti-patterns/process-anti-patterns.md

@@ -279,7 +279,7 @@ defmodule Counter do
 
   @doc "Bumps the value of the given counter."
   def bump(name \\ __MODULE__, value) do
-    Agent.get_and_update(fn state -> {state, value + state} end)
+    Agent.get_and_update(name, fn state -> {state, value + state} end)
   end
 end
 ```

lib/elixir/pages/cheatsheets/enum-cheat.cheatmd

@@ -689,14 +689,14 @@ iex> Enum.map_join(cart, ", ", & &1.fruit)
 "apple, banana, orange"
 ```
 
-### [`intersperse(enum, separator \\ "")`](`Enum.intersperse/2`)
+### [`intersperse(enum, separator)`](`Enum.intersperse/2`)
 
 ```elixir
 iex> Enum.intersperse(["apple", "banana", "orange"], ", ")
 ["apple", ", ", "banana", ", ", "orange"]
 ```
 
-### [`map_intersperse(enum, separator \\ "", mapper)`](`Enum.map_intersperse/3`)
+### [`map_intersperse(enum, separator, mapper)`](`Enum.map_intersperse/3`)
 
 ```elixir
 iex> Enum.map_intersperse(cart, ", ", & &1.fruit)
@@ -976,7 +976,7 @@ iex> Enum.chunk_every(cart, 2)
 ]
 ```
 
-### [`chunk_every(enum, count, step, leftover \\ [])`](`Enum.chunk_every/2`)
+### [`chunk_every(enum, count, step, leftover \\ [])`](`Enum.chunk_every/4`)
 
 ```elixir
 iex> Enum.chunk_every(cart, 2, 2, [:elements, :to_complete])
@@ -1019,7 +1019,7 @@ iex> Enum.zip(fruits, counts)
 
 See `Enum.zip/1` for zipping many collections at once.
 
-### [`zip_with(enum1, enum2, fun)`](`Enum.zip_with/2`)
+### [`zip_with(enum1, enum2, fun)`](`Enum.zip_with/3`)
 
 ```elixir
 iex> fruits = ["apple", "banana", "orange"]

lib/elixir/pages/getting-started/introduction.md

@@ -29,7 +29,7 @@ For now, let's start by running `iex` (or `iex.bat` if you are on Windows PowerS
 Open up `iex` and type the following expressions:
 
 ```elixir
-Erlang/OTP 26 [64-bit] [smp:2:2] [...]
+Erlang/OTP 27 [64-bit] [smp:2:2] [...]
 
 Interactive Elixir - press Ctrl+C to exit
 iex(1)> 40 + 2

lib/elixir/pages/mix-and-otp/docs-tests-and-with.md

@@ -181,7 +181,7 @@ defmodule KV.Command do
 end
 ```
 
-Before we implement this function, let's change our server to start using our new `parse/1` and `run/1` functions. Remember, our `read_line/1` function was also crashing when the client closed the socket, so let's take the opportunity to fix it, too. Open up `lib/kv/server.ex` and replace the existing server definition:
+Before we implement this function, let's change our server to start using our new `parse/1` and `run/2` functions. Remember, our `read_line/1` function was also crashing when the client closed the socket, so let's take the opportunity to fix it, too. Open up `lib/kv/server.ex` and replace the existing server definition:
 
 ```elixir
   defp serve(socket) do
@@ -289,7 +289,7 @@ You can read more about `with/1` in our documentation.
 
 ## Running commands
 
-The last step is to implement `KV.Command.run/1` to run the parsed commands on top of buckets. Its implementation is shown below:
+The last step is to implement `KV.Command.run/2` to run the parsed commands on top of buckets. Its implementation is shown below:
 
 ```elixir
   @doc """
@@ -354,7 +354,7 @@ Our server functionality is almost complete. Only tests are missing.
 
 ## Integration tests
 
-`KV.Command.run/1`'s implementation is sending commands directly to the `KV` module, which is using a local registry to name processes. This means if we have two tests sending messages to the same bucket, our tests will conflict with each other (and likely fail). One might think this would be a reason to use mocks and other strategies to keep our tests isolated, but such techniques often make our testing environment too distant from how our code actually runs in production, and you may end-up with bugs lurking.
+`KV.Command.run/2`'s implementation is sending commands directly to the `KV` module, which is using a local registry to name processes. This means if we have two tests sending messages to the same bucket, our tests will conflict with each other (and likely fail). One might think this would be a reason to use mocks and other strategies to keep our tests isolated, but such techniques often make our testing environment too distant from how our code actually runs in production, and you may end-up with bugs lurking.
 
 Luckily, there is a technique that we have been using throughout this guide that would be equally applicable here: it is ok to rely on the local registry as long as each test uses unique names. Using a combination of the test module and test name is more than enough to guarantee that.
 

lib/elixir/pages/mix-and-otp/dynamic-supervisor.md

@@ -72,7 +72,7 @@ Given our buckets can already be supervised, you may be thinking to start them a
 
 ```elixir
 children = [
-  {Registry, name: KV, keys: :unique}
+  {Registry, name: KV, keys: :unique},
   {KV.Bucket, name: {:via, Registry, {KV, "shopping"}}}
 ]
 ```
@@ -223,7 +223,7 @@ Not only that, as you create new buckets on the terminal, you should see new pro
 
 ```elixir
 iex> KV.create_bucket("shopping")
-#PID<0.89.0>
+{:ok, #PID<0.89.0>}
 ```
 
 We will leave it up to you to further explore what Observer provides. Note you can double-click any process in the supervision tree to retrieve more information about it, as well as right-click a process to send "a kill signal", a perfect way to emulate failures and see if your supervisor reacts as expected.

lib/elixir/pages/mix-and-otp/genservers.md

@@ -300,7 +300,7 @@ Open up `test/kv/server_test.exs` and add this new test:
 
 The test creates a bucket and subscribes to it. Then it opens up another TCP connection to send commands. For each command sent, we expect the subscribed socket to receive a message.
 
-To make the test pass, we need to change `KV.Command` to parse the new `SUBSCRIBE` command and then run it. Open up `lib/kv/commands.ex` and then first change the `parse/1` definition to the following:
+To make the test pass, we need to change `KV.Command` to parse the new `SUBSCRIBE` command and then run it. Open up `lib/kv/command.ex` and then first change the `parse/1` definition to the following:
 
 ```elixir
   def parse(line) do

lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md

@@ -221,7 +221,7 @@ Let's change `start/2` in `lib/kv.ex` once more, to add the task supervisor to o
   end
 ```
 
-We'll now start a `Task.Supervisor` process with name `KV.TaskSupervisor`. Keep in mind that the order children are started matters. For example, the acceptor must come last because, if it comes first, it means our application can start accepting requests before the `Task.Supervisor` is running or before we can locate buckets. Shutting down an application will also stop the children in reverse order, guaranteeing a clean termination.
+We'll now start a `Task.Supervisor` process with name `KV.ServerSupervisor`. Keep in mind that the order children are started matters. For example, the acceptor must come last because, if it comes first, it means our application can start accepting requests before the `Task.Supervisor` is running or before we can locate buckets. Shutting down an application will also stop the children in reverse order, guaranteeing a clean termination.
 
 Now we need to change `loop_acceptor/1` to use `Task.Supervisor` to serve each request:
 

lib/elixir/pages/references/compatibility-and-deprecations.md

@@ -122,7 +122,7 @@ Version | Deprecated feature                                  | Replaced by (ava
 [v1.15] | `Regex.regex?/1`                                    | `Kernel.is_struct/2` (`Kernel.is_struct(term, Regex)`) (v1.11)
 [v1.15] | `Logger.warn/2`                                     | `Logger.warning/2` (v1.11)
 [v1.14] | `use Bitwise`                                       | `import Bitwise` (v1.0)
-[v1.14] | `~~~/1`                                             | `bnot/2` (v1.0)
+[v1.14] | `~~~/1`                                             | `bnot/1` (v1.0)
 [v1.14] | `Application.get_env/3` and similar in module body  | `Application.compile_env/3` (v1.10)
 [v1.14] | Compiled patterns in `String.starts_with?/2`        | Pass a list of strings instead (v1.0)
 [v1.14] | `Mix.Tasks.Xref.calls/1`                            | Compilation tracers (outlined in `Code`) (v1.10)

lib/elixir/pages/references/gradual-set-theoretic-types.md

@@ -81,7 +81,7 @@ You can represent all _proper_ lists as `list()`, which also includes the empty
 
 You can also specify the type of the list element as argument. For example, `list(integer())` represents the values `[]` and `[1, 2, 3]`, but not `[1, "two", 3]`.
 
-Internally, Elixir represents the type `list(a)` as the union two distinct types, `empty_list()` and `not_empty_list(a)`. In other words, `list(integer())` is equivalent to `empty_list() or non_empty_list(integer())`.
+Internally, Elixir represents the type `list(a)` as the union two distinct types, `empty_list()` and `non_empty_list(a)`. In other words, `list(integer())` is equivalent to `empty_list() or non_empty_list(integer())`.
 
 #### Improper lists