refactor: Ensure that we're using options and results as much as possible.

lib/gcode.ex

@@ -1,5 +1,6 @@
 defmodule Gcode do
-  alias Gcode.{Model.Program, Model.Serialise, Result}
+  alias Gcode.{Model.Program, Model.Serialise}
+  use Gcode.Result
 
   @moduledoc """
   Gcode - a library for parsing and serialising G-code.
@@ -23,9 +24,7 @@ defmodule Gcode do
   def serialise(%Program{} = program) do
     program
     |> Serialise.serialise()
-    |> Result.Enum.map(fn block ->
-      {:ok, "#{block}\r\n"}
-    end)
+    |> Result.Enum.map(&ok("#{&1}\r\n"))
     |> Result.Enum.join("")
   end
 end

lib/gcode/model/comment/serialise.ex

@@ -17,5 +17,5 @@ defimpl Gcode.Model.Serialise, for: Gcode.Model.Comment do
     |> ok()
   end
 
-  def serialise(_comment), do: {:error, {:serialise_error, "Invalid comment"}}
+  def serialise(_comment), do: error({:serialise_error, "Invalid comment"})
 end

lib/gcode/model/program/enumerable.ex

@@ -1,20 +1,24 @@
 defimpl Enumerable, for: Gcode.Model.Program do
   alias Gcode.Model.Program
+  use Gcode.Result
 
   @moduledoc """
   Implements the `Enumerable` protocol for `Program`.
   """
 
-  @spec count(Program.t()) :: {:ok, non_neg_integer()} | {:error, module}
-  def count(%Program{elements: elements}), do: {:ok, Enum.count(elements)}
+  @spec count(Program.t()) :: Result.t(non_neg_integer, module)
+  def count(%Program{elements: elements}),
+    do: {:ok, Enum.count(elements)}
 
-  @spec member?(Program.t(), any) :: {:error, module} | {:ok, boolean}
-  def member?(%Program{elements: elements}, element), do: Enumerable.member?(elements, element)
+  @spec member?(Program.t(), any) :: Result.t(boolean, module)
+  def member?(%Program{elements: elements}, element),
+    do: Enumerable.member?(elements, element)
 
   @spec reduce(Program.t(), Enumerable.acc(), Enumerable.reducer()) :: Enumerable.result()
-  def reduce(%Program{elements: elements}, acc, fun), do: Enumerable.reduce(elements, acc, fun)
+  def reduce(%Program{elements: elements}, acc, fun),
+    do: Enumerable.reduce(elements, acc, fun)
 
   @spec slice(Program.t()) ::
-          {:ok, non_neg_integer, Enumerable.slicing_fun()} | {:error, module}
+          {:ok, non_neg_integer, Enumerable.slicing_fun()} | Result.error(module)
   def slice(%Program{elements: elements}), do: Enumerable.slice(elements)
 end

test/gcode/model/comment/serialise_test.exs

@@ -1,6 +1,7 @@
 defmodule Gcode.Model.Comment.SerialiseTest do
   use ExUnit.Case, async: true
   alias Gcode.Model.{Comment, Serialise}
+  use Gcode.Result
   @moduledoc false
 
   describe "serialise/1" do
@@ -13,8 +14,8 @@ defmodule Gcode.Model.Comment.SerialiseTest do
       """
 
       actual =
-        with {:ok, comment} <- Comment.init(comment),
-             {:ok, comment} <- Serialise.serialise(comment),
+        with ok(comment) <- Comment.init(comment),
+             ok(comment) <- Serialise.serialise(comment),
              do: comment
 
       expected = ~w[(This) (is) (a) (test)]

test/gcode/model/skip/serialise_test.exs

@@ -1,12 +1,15 @@
 defmodule Gcode.Model.Skip.SerialiseTest do
   use ExUnit.Case, async: true
   alias Gcode.Model.{Serialise, Skip}
+  use Gcode.Result
   @moduledoc false
 
   describe "serialise/1" do
     test "when the skip has a number, it formats it correctly" do
       actual =
-        with {:ok, skip} <- Skip.init(0), {:ok, skip} <- Serialise.serialise(skip), do: skip
+        with ok(skip) <- Skip.init(0),
+             ok(skip) <- Serialise.serialise(skip),
+             do: skip
 
       expected = ~w[/0]
 
@@ -14,7 +17,10 @@ defmodule Gcode.Model.Skip.SerialiseTest do
     end
 
     test "when the skip has no number, it formats it correctly" do
-      actual = with {:ok, skip} <- Skip.init(), {:ok, skip} <- Serialise.serialise(skip), do: skip
+      actual =
+        with ok(skip) <- Skip.init(),
+             ok(skip) <- Serialise.serialise(skip),
+             do: skip
 
       expected = ~w[/]
 

test/gcode/model/word/serialise_test.exs

@@ -1,12 +1,15 @@
 defmodule Gcode.Model.Word.SerialiseTest do
   use ExUnit.Case, async: true
   alias Gcode.Model.{Serialise, Word}
+  use Gcode.Result
   @moduledoc false
 
   describe "serialise/1" do
     test "formats the word and the address correctly" do
       actual =
-        with {:ok, word} <- Word.init("G", 0), {:ok, word} <- Serialise.serialise(word), do: word
+        with ok(word) <- Word.init("G", 0),
+             ok(word) <- Serialise.serialise(word),
+             do: word
 
       expected = ~w[G0]
 

test/support/describe_case.ex

@@ -29,7 +29,7 @@ defmodule DescribeCase do
   end
 
   def make_block(input) do
-    {:ok, block} = Block.init()
+    ok(block) = Block.init()
 
     input
     |> String.trim()
@@ -40,9 +40,9 @@ defmodule DescribeCase do
     |> Result.Enum.reduce_while_ok(block, &Block.push(&2, &1))
   end
 
-  @spec make_program(binary) :: {:error, any} | {:ok, any}
+  @spec make_program(binary) :: Result.t()
   def make_program(input) do
-    {:ok, program} = Program.init()
+    ok(program) = Program.init()
 
     input
     |> String.trim()