Use backtick in "returns true" and "returns false" in docs (#7865)

[ci skip]

Author: eksperimental

CHANGELOG.md

@@ -127,7 +127,7 @@ Percentage | Module
   * [Kernel] Warn on unsupported nested comparisons such as `x < y < z`
   * [Kernel] Warn if redefining documentation across clauses of the same definition
   * [Kernel] Warn on unnecessary quotes around atoms, keywords and calls
-  * [Macro] Add `Macro.special_form?/2` and `Macro.operator?/2` that returns true if the given name/arity is a special form or operator respectively
+  * [Macro] Add `Macro.special_form?/2` and `Macro.operator?/2` that returns `true` if the given name/arity is a special form or operator respectively
   * [Macro.Env] Add `Macro.Env.vars/1` and `Macro.Env.has_var?/2` that gives access to environment data without accessing private fields
   * [Regex] Include endianness in the regex version. This allows regexes to be recompiled when an archive is installed in a system with a different endianness
   * [Registry] Add `Registry.count/1` and `Registry.count_match/4`

lib/elixir/lib/calendar.ex

@@ -123,7 +123,7 @@ defmodule Calendar do
   @callback months_in_year(year) :: month
 
   @doc """
-  Returns true if the given year is a leap year.
+  Returns `true` if the given year is a leap year.
 
   A leap year is a year of a longer length than normal. The exact meaning
   is up to the calendar. A calendar must return `false` if it does not support

lib/elixir/lib/calendar/date.ex

@@ -132,7 +132,7 @@ defmodule Date do
   end
 
   @doc """
-  Returns true if the year in the given `date` is a leap year.
+  Returns `true` if the year in the given `date` is a leap year.
 
   ## Examples
 

lib/elixir/lib/enum.ex

@@ -273,7 +273,7 @@ defmodule Enum do
   end
 
   @doc """
-  Returns true if the given `fun` evaluates to true on all of the items in the enumerable.
+  Returns `true` if the given `fun` evaluates to true on all of the items in the enumerable.
 
   It stops the iteration at the first invocation that returns `false` or `nil`.
 
@@ -311,7 +311,7 @@ defmodule Enum do
   end
 
   @doc """
-  Returns true if the given `fun` evaluates to true on any of the items in the enumerable.
+  Returns `true` if the given `fun` evaluates to true on any of the items in the enumerable.
 
   It stops the iteration at the first invocation that returns a truthy value (neither `false` nor `nil`).
 

lib/elixir/lib/kernel.ex

@@ -16,19 +16,19 @@ defmodule Kernel do
       data type handling, etc
     * macros for control-flow and defining new functionality (modules, functions, and so on)
     * [guard](guards.html) checks for augmenting pattern matching
-    
+
   You can use `Kernel` functions/macros without the `Kernel` prefix anywhere in
   Elixir code as all its functions and macros are automatically imported. For
   example, in IEx:
 
       iex> is_number(13)
       true
 
-  If you don't want to import a function or macro from `Kernel`, use the `:except` 
+  If you don't want to import a function or macro from `Kernel`, use the `:except`
   option and then list the function/macro by arity:
 
         import Kernel, except: [if: 2, unless: 2]
-        
+
   See `Kernel.SpecialForms.import/2` for more information on importing.
 
   Elixir also has special forms that are always imported and
@@ -1392,8 +1392,8 @@ defmodule Kernel do
 
   The items are only considered to be exactly equal if they
   have the same value and are of the same type. For example,
-  `1 == 1.0` returns true, but since they are of different
-  types, `1 === 1.0` returns false.
+  `1 == 1.0` returns `true`, but since they are of different
+  types, `1 === 1.0` returns `false`.
 
   All terms in Elixir can be compared with each other.
 

lib/elixir/lib/macro.ex

@@ -1273,7 +1273,7 @@ defmodule Macro do
   defp do_expand_once(other, _env), do: {other, false}
 
   @doc """
-  Returns true if the given name and arity is a special form.
+  Returns `true` if the given name and arity is a special form.
   """
   @since "1.7.0"
   @spec special_form?(name :: atom(), arity()) :: boolean()
@@ -1282,7 +1282,7 @@ defmodule Macro do
   end
 
   @doc """
-  Returns true if the given name and arity is an operator.
+  Returns `true` if the given name and arity is an operator.
   """
   @since "1.7.0"
   @spec operator?(name :: atom(), arity()) :: boolean()
@@ -1291,7 +1291,7 @@ defmodule Macro do
   def operator?(name, arity) when is_atom(name) and is_integer(arity), do: false
 
   @doc """
-  Returns true if the given quoted expression is an AST literal.
+  Returns `true` if the given quoted expression is an AST literal.
   """
   @since "1.7.0"
   @spec quoted_literal?(literal) :: true

lib/elixir/lib/string.ex

@@ -389,13 +389,13 @@ defmodule String do
 
   Note this function can split within or across grapheme boundaries.
   For example, take the grapheme "é" which is made of the characters
-  "e" and the acute accent. The following returns true:
+  "e" and the acute accent. The following returns `true`:
 
       iex> String.split(String.normalize("é", :nfd), "e")
       ["", "́"]
 
   However, if "é" is represented by the single character "e with acute"
-  accent, then it will return false:
+  accent, then it will return `false`:
 
       iex> String.split(String.normalize("é", :nfc), "e")
       ["é"]
@@ -2064,13 +2064,13 @@ defmodule String do
 
   Note this function can match within or across grapheme boundaries.
   For example, take the grapheme "é" which is made of the characters
-  "e" and the acute accent. The following returns true:
+  "e" and the acute accent. The following returns `true`:
 
       iex> String.contains?(String.normalize("é", :nfd), "e")
       true
 
   However, if "é" is represented by the single character "e with acute"
-  accent, then it will return false:
+  accent, then it will return `false`:
 
       iex> String.contains?(String.normalize("é", :nfc), "e")
       false

lib/mix/lib/mix.ex

@@ -158,12 +158,12 @@ defmodule Mix do
   Where `&clean_extra/1` would be a function in your `mix.exs`
   with extra cleanup logic.
 
-  Aliases defined in the current project do not affect its dependencies and 
+  Aliases defined in the current project do not affect its dependencies and
   aliases defined in dependencies are not accessible from the current project.
 
   Aliases can be used very powerfully to also run Elixir scripts and
   bash commands, for example:
-      
+
       # priv/hello.exs
       IO.puts("hello")
 
@@ -179,10 +179,10 @@ defmodule Mix do
         ]
       end
 
-  In the example above we have created 2 aliases, the first example 
+  In the example above we have created 2 aliases, the first example
   `taskalias` will run task `hex.info`, then (`run`)[`Mix.Tasks.Run`]
-  to run an Elixir script, then (`cmd`)[`Mix.Tasks.Cmd`] to run a 
-  command line bash script. This shows how powerful aliases mixed 
+  to run an Elixir script, then (`cmd`)[`Mix.Tasks.Cmd`] to run a
+  command line bash script. This shows how powerful aliases mixed
   with mix tasks can be.
 
   `taskalias2` shows a limitation of tasks where only one of the given
@@ -302,7 +302,7 @@ defmodule Mix do
   end
 
   @doc """
-  Returns true if Mix is in debug mode.
+  Returns `true` if Mix is in debug mode.
   """
   def debug? do
     Mix.State.get(:debug, false)

lib/mix/lib/mix/dep.ex

@@ -422,7 +422,7 @@ defmodule Mix.Dep do
   def diverged?(%Mix.Dep{}), do: false
 
   @doc """
-  Returns true if the depednency is compilable.
+  Returns `true` if the depednency is compilable.
   """
   def compilable?(%Mix.Dep{status: {:elixirlock, _}}), do: true
   def compilable?(%Mix.Dep{status: {:noappfile, _}}), do: true