feat!: comprehensive errors for list schematics (#26)

Author: mhanberg

.github/workflows/ci.yml

@@ -56,7 +56,7 @@ jobs:
 
   doctests:
     runs-on: ubuntu-latest
-    name: Doctests (1.14..x/25.x)
+    name: Doctests (1.14.x/25.x)
 
     steps:
     - uses: actions/checkout@v2
@@ -81,7 +81,7 @@ jobs:
 
   formatter:
     runs-on: ubuntu-latest
-    name: Formatter (1.14.x/25.x)
+    name: Formatter (1.15.x/25.x)
 
     steps:
     - uses: actions/checkout@v2

lib/schematic.ex

@@ -45,6 +45,11 @@ defmodule Schematic do
             }
   end
 
+  defmodule Error do
+    @moduledoc false
+    defstruct []
+  end
+
   @doc """
   Specifies that the data can be **any**thing.
 
@@ -276,12 +281,14 @@ defmodule Schematic do
   @doc """
   Specifies that the data is a list whose items unify to the given schematic.
 
+  Lists whose elements do not unify return a list of `:ok` and `:error` tuples.
+
   ## Usage
 
   ```elixir
   iex> schematic = list(oneof([str(), int()]))
   iex> {:ok, ["one", 2, "three"]} = unify(schematic, ["one", 2, "three"])
-  iex> {:error, "expected a list of either a string or an integer"} = unify(schematic, ["one", 2, :three])
+  iex> {:error, [ok: "one", ok: 2, error: "expected either a string or an integer"]} = unify(schematic, ["one", 2, :three])
   ```
   """
   @spec list(t() | lazy_schematic() | literal()) :: t()
@@ -304,21 +311,18 @@ defmodule Schematic do
       unify:
         telemetry_wrap(:list, %{}, fn input, dir ->
           if is_list(input) do
-            Enum.reduce_while(input, {:ok, []}, fn el, {:ok, acc} ->
+            Enum.map_reduce(input, [], fn el, acc ->
               case schematic.().unify.(el, dir) do
-                {:ok, output} ->
-                  {:cont, {:ok, [output | acc]}}
-
-                {:error, _error} ->
-                  {:halt, {:error, ~s|expected #{message.()}|}}
+                {:ok, output} -> {output, [{:ok, output} | acc]}
+                {:error, error} -> {%Error{}, [{:error, error} | acc]}
               end
             end)
-            |> then(fn
-              {:ok, result} ->
-                {:ok, Enum.reverse(result)}
-
-              error ->
-                error
+            |> then(fn {result, errors} ->
+              if %Error{} in result do
+                {:error, Enum.reverse(errors)}
+              else
+                {:ok, result}
+              end
             end)
           else
             {:error, ~s|expected a list|}

test/schematic_test.exs

@@ -89,9 +89,16 @@ defmodule SchematicTest do
     end
 
     test "list/1" do
-      schematic = list(int())
-      input = [1, 2, 3]
-      assert {:ok, input} == unify(schematic, input)
+      schematic = list(map(%{name: str()}))
+
+      assert {:ok, [%{name: "mitch"}, %{name: "scott"}]} ==
+               unify(schematic, [%{name: "mitch"}, %{name: "scott"}])
+
+      assert {:error, "expected a list"} == unify(schematic, "foo")
+
+      assert {:error,
+              [{:ok, _}, {:error, %{name: "expected a string"}}, {:error, "expected a map"}]} =
+               unify(schematic, [%{name: "mitch"}, %{name: 1}, 2])
     end
 
     test "tuple/2" do
@@ -462,7 +469,10 @@ defmodule SchematicTest do
                 "bob" => "expected 99",
                 "dave" => %{
                   "first" => "expected an integer",
-                  "second" => "expected a list of either a list or a map",
+                  "second" => [
+                    error: "expected either a list or a map",
+                    error: "expected either a list or a map"
+                  ],
                   "teacher" => %{
                     "grade" => "expected an integer",
                     "name" => "expected a string",
@@ -721,7 +731,7 @@ defmodule SchematicTest do
       assert {:error,
               %{
                 recursive: %{recursive: "expected a map"},
-                recursive_list: "expected a list of a map"
+                recursive_list: [error: "expected a map"]
               }} ==
                unify(schematic, %{
                  foo: "hi",