Set up MarkdownCodeBlockFormatter

.formatter.exs

@@ -1,3 +1,4 @@
 [
-  inputs: ["mix.exs", "{exercises,bin}/**/*.{ex,exs}"]
+  plugins: [MarkdownCodeBlockFormatter],
+  inputs: ["mix.exs", "{exercises,bin}/**/*.{ex,exs}", "{concepts,exercises,docs,reference}/**/*.md", "*.md"]
 ]

concepts/anonymous-functions/about.md

@@ -32,7 +32,7 @@ Anonymous functions may be created with the [`&` capture shorthand][kernel-captu
   fn x, y -> abs(x) + abs(y) end
 
   # We can write:
-  & abs(&1) + abs(&2)
+  &(abs(&1) + abs(&2))
   ```
 
 - The `&` capture operator can also be used to [_capture_ existing named function][capture]:

concepts/basics/introduction.md

@@ -5,12 +5,16 @@
 Elixir is a dynamically-typed language, meaning that the type of a variable is only checked at runtime. Using the match `=` operator, we can bind a value of any type to a variable name:
 
 ```elixir
-count = 1 # Bound an integer value of 1
-count = 2 # You may re-bind variables
+# Bound an integer value of 1
+count = 1
+# You may re-bind variables
+count = 2
 
-count = false # You may re-bind any type to a variable
+# You may re-bind any type to a variable
+count = false
 
-message = "Success!" # Strings can be created by enclosing characters within double quotes
+# Strings can be created by enclosing characters within double quotes
+message = "Success!"
 ```
 
 ## Modules

concepts/binaries/about.md

@@ -11,7 +11,8 @@
 
 ```elixir
 <<255>> == <<0xFF>>
-<<256>> == <<0>> # Overflowing bits are truncated
+# Overflowing bits are truncated
+<<256>> == <<0>>
 <<256::size(16)>> == <<1, 0>>
 
 <<"Hello">> == <<72, 101, 108, 108, 111>>

concepts/binaries/introduction.md

@@ -8,7 +8,8 @@ Binary literals are defined using the bitstring special form `<<>>`. When defini
 
 ```elixir
 <<255>> == <<0xFF>>
-<<256>> == <<0>> # Overflowing bits are truncated
+# Overflowing bits are truncated
+<<256>> == <<0>>
 <<2, 4, 6, 8, 10, 12, 14, 16>> == <<0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10>>
 ```
 

concepts/booleans/about.md

@@ -20,8 +20,11 @@ Boolean operators use _short-circuit evaluation_, which means that the expressio
 Each of the operators has a different precedence, where `not/1` is evaluated before `and/2` and `or/2`. Brackets can be used to evaluate one part of the expression before the others:
 
 ```elixir
-not true and false # => false
-not (true and false) # => true
+not true and false
+# => false
+
+not (true and false)
+# => true
 ```
 
 When writing a function that returns a boolean value, it is [idiomatic to end the function name][naming] with a `?`. The same convention can be used for variables that store boolean values.

concepts/docs/about.md

@@ -74,6 +74,8 @@ If you have Elixir installed on your computer, you can use it in [the interactiv
 
 In `iex`, you can type [`h`][iex-h], followed by a space and a module name or a function name, to read its documentation.
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 iex()> h String.upcase/1
 # def upcase(string, mode \\ :default)

concepts/enum/about.md

@@ -47,6 +47,7 @@ Enum.reduce([4, 20, 31, 9, 2], nil, fn x, acc ->
     x <= acc -> acc
   end
 end)
+
 # => 31
 ```
 

concepts/exceptions/about.md

@@ -33,6 +33,7 @@ defmodule MyCustomizedError do
     case value do
       [] ->
         %MyCustomizedError{}
+
       _ ->
         %MyCustomizedError{message: "Alert: " <> value}
     end

concepts/exceptions/introduction.md

@@ -28,6 +28,7 @@ defmodule MyCustomizedError do
     case value do
       [] ->
         %MyCustomizedError{}
+
       _ ->
         %MyCustomizedError{message: "Alert: " <> value}
     end

concepts/file/about.md

@@ -58,7 +58,7 @@ Reading a file with [`File.read/1`][file-read] is going to load the whole file i
 
 ```elixir
 File.stream!("file.txt")
-|> Stream.map(& &1 <> "!")
+|> Stream.map(&(&1 <> "!"))
 |> Stream.into(File.stream!("new_file.txt"))
 |> Stream.run()
 ```

concepts/io/about.md

@@ -28,6 +28,7 @@ When this happens, you might want to use [`IO.inspect/2`][io-inspect] instead.
 |> IO.inspect(label: "step 1")
 |> String.downcase()
 |> IO.inspect(label: "step 2")
+
 # > step 1: "HELLO"
 # > step 2: "hello"
 # => "hello"

concepts/keyword-lists/about.md

@@ -21,6 +21,8 @@ Keyword.keyword?([{"month", "April"}])
 
 If you want to use characters other than letters, numbers, and `_` in the key, you need to wrap it in quotes. However, that does not make it a string - it is still an atom.
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 Keyword.keyword?(["day of week": "Monday"])
 # => true
@@ -59,6 +61,8 @@ if age >= 16, do: "beer", else: "no beer"
 
 This may look like `if` accepts two arguments, but the `do:` and `else:` pair is actually a single argument - a keyword list. The same code could be written as:
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 if age >= 16, [do: "beer", else: "no beer"]
 # or

concepts/links/about.md

@@ -52,6 +52,7 @@ pid = spawn_link(fn -> :timer.sleep(50_000) end)
 self()
 |> Process.info()
 |> Keyword.get(:links)
+
 # => [#PID<0.126.0>]
 ```
 
@@ -69,6 +70,7 @@ The current value of the flag can be checked using [`Process.info/1`][process-in
 pid
 |> Process.info()
 |> Keyword.get(:trap_exit)
+
 # => false
 ```
 

concepts/list-comprehensions/about.md

@@ -2,10 +2,12 @@
 
 [Comprehension][for] provide a facility for transforming _Enumerables_ easily and declaratively. They are _syntactic sugar_ for iterating through enumerables in Elixir.
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 for s <- ["a", "b", "hello", "c"], # 1. generator
-  String.length(s) == 1, # 2. filter
-  into: "", # 3. collectable
+  String.length(s) == 1,           # 2. filter
+  into: "",                        # 3. collectable
   do: String.upcase(s)
 
 # => "ABC"
@@ -29,6 +31,7 @@ for x <- [0, 1],
     y <- [0, 1] do
   {x, y}
 end
+
 # => [{0, 0}, {0, 1}, {1, 0}, {1, 1}]
 ```
 
@@ -49,6 +52,7 @@ for pair <- [a: "string"],
     {atom, str} = pair do
   str
 end
+
 # => ["string"]
 ```
 

concepts/list-comprehensions/introduction.md

@@ -23,6 +23,7 @@ for {atom, number} <- [a: 1, b: 2, c: 3, d: 4],
     rem(number, 2) == 0 do
   atom
 end
+
 # => [:b, :d]
 ```
 
@@ -33,5 +34,6 @@ for x <- [0, 1],
     y <- [0, 1] do
   {x, y}
 end
+
 # => [{0, 0}, {0, 1}, {1, 0}, {1, 1}]
 ```

concepts/lists/about.md

@@ -14,11 +14,14 @@ Lists can be written in literal form, head-tail notation, (which uses the `cons`
 
 # Head-tail Notation
 []
-[1 | []] # same as [1]
-[1 | [2 | [3 | []]]] # same as [1, 2, 3]
+# same as [1]
+[1 | []]
+# same as [1, 2, 3]
+[1 | [2 | [3 | []]]]
 
 # Mixed
-[1 | [2, 3]] # same as [1, 2, 3]
+# same as [1, 2, 3]
+[1 | [2, 3]]
 ```
 
 There can also be more than one element before the _cons_ (`|`) operator.
@@ -46,7 +49,8 @@ We can achieve the same result by prepending an element to the reversed list, an
 [1, 2, 3] ++ [4] ++ [5] ++ [6]
 
 # Prepend to the start of a list (faster, due to the nature of linked lists)
-[6 | [5 | [4 | [3, 2, 1]]]] # then reverse!
+[6 | [5 | [4 | [3, 2, 1]]]]
+# then reverse!
 ```
 
 There are several common `Kernel` functions for lists:

concepts/maps/about.md

@@ -20,8 +20,8 @@
   # A map with the string key "a" associated to the float value 2.0
   %{"a" => 2.0}
 
-  # A map with the map key %{} with the list value [1,2,3]
-  %{%{} => [1,2,3]}
+  # A map with the map key %{} with the list value [1 ,2, 3]
+  %{%{} => [1, 2, 3]}
 
   # A map with keys of different types
   %{:a => 1, "b" => 2}

concepts/module-attributes-as-constants/introduction.md

@@ -4,7 +4,6 @@ In Elixir, we can define module attributes which can be used as constants in our
 
 ```elixir
 defmodule Example do
-
   # Defines the attribute as the value 1
   @constant_number 1
 

concepts/multiple-clause-functions/introduction.md

@@ -8,6 +8,7 @@ Elixir offers _multiple function clauses_ and _guards_ to write:
 def number(n) when n == 7 do
   "Awesome, that's my favorite"
 end
+
 def number(_n) do
   "That's not my favorite"
 end

concepts/nil/about.md

@@ -9,6 +9,8 @@ favorite_color = nil
 
 `nil` is an atom, but it is usually written as `nil`, not `:nil`. The boolean values `true` and `false` are atoms too.
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 nil === :nil
 # => true

concepts/pipe-operator/about.md

@@ -31,7 +31,7 @@ It is a matter of personal preference when to use the pipe operator and when not
 
   ```elixir
   # do
-  String.split("hello" , "")
+  String.split("hello", "")
 
   # don't
   "hello" |> String.split("")

concepts/pipe-operator/introduction.md

@@ -6,5 +6,6 @@ The `|>` operator is called the pipe operator. It can be used to chain function
 "hello"
 |> String.upcase()
 |> Kernel.<>("?!")
+
 # => "HELLO?!"
 ```

concepts/ranges/about.md

@@ -14,7 +14,7 @@
 Enum.to_list(9..1)
 # => [9, 8, 7, 6, 5, 4, 3, 2, 1]
 
-Enum.map(?A..?F, & <<&1>>)
+Enum.map(?A..?F, &<<&1>>)
 ["A", "B", "C", "D", "E", "F"]
 ```
 

concepts/strings/about.md

@@ -30,6 +30,7 @@ Any Elixir expression is valid inside the interpolation. If a string is given, t
 # => "And lists, too!"
 
 "But not functions: #{fn x -> x end}"
+
 # => ** (Protocol.UndefinedError) protocol String.Chars not implemented for #Function<7.126501267/1 in :erl_eval.expr/5> of type Function
 #        (elixir 1.10.1) lib/string/chars.ex:3: String.Chars.impl_for!/1
 #        (elixir 1.10.1) lib/string/chars.ex:22: String.Chars.to_string/1

concepts/tail-call-recursion/about.md

@@ -29,6 +29,7 @@ Tail-recursive functions allow for [tail call optimization][tail-call-optimizati
   def reverse(list), do: do_reverse(list, [])
 
   defp do_reverse([], acc), do: acc
+
   defp do_reverse([head | tail], acc) do
     do_reverse(tail, [head | acc])
   end

concepts/tasks/about.md

@@ -98,6 +98,7 @@ If you need to run tasks that perform different operations, you might need `Task
 inputs
 |> Enum.map(&Task.async(fn -> function.(&1) end))
 |> Task.await_many(1_000)
+
 # => ** (exit) exited in: Task.await_many([...], 1000)
 #        ** (EXIT) time out
 #        (elixir 1.11.3) lib/task.ex:725: Task.await_many/5

concepts/try-rescue-else-after/about.md

@@ -18,5 +18,6 @@ else
 after
   :some_action
 end
+
 # => :success
 ```

concepts/try-rescue-else-after/introduction.md

@@ -18,5 +18,6 @@ else
 after
   :some_action
 end
+
 # => :success
 ```

concepts/try-rescue/about.md

@@ -4,6 +4,8 @@
 
 For example:
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 try do                             #1
   raise RuntimeError, "error"      #2

concepts/try-rescue/introduction.md

@@ -2,6 +2,8 @@
 
 Elixir provides a construct for rescuing from errors using `try .. rescue`
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 try do                             #1
   raise RuntimeError, "error"      #2

concepts/with/about.md

@@ -8,10 +8,15 @@ Let's say that you want to validate a username with several checks. You might re
 case check_ascii(username) do
   {:ok, username} ->
     case check_starts_with_letter(username) do
-      {:ok, username} -> {:ok, username}
-      {:error, "usernames may only start with a letter"} = err -> err
-  end
-  {:error, "usernames may only contain ascii letters"} = err -> err
+      {:ok, username} ->
+        {:ok, username}
+
+      {:error, "usernames may only start with a letter"} = err ->
+        err
+    end
+
+  {:error, "usernames may only contain ascii letters"} = err ->
+    err
 end
 ```
 

docs/REPRESENTER_NORMALIZATIONS.md

@@ -87,6 +87,8 @@ Types are written without.
 
 ### Before
 
+[]: # (elixir-formatter-disable-next-block)
+
 ```elixir
 defmodule    Fake   do
         @type foo() :: integer() | atom