@spec check(t(), %{required(key()) => need()}, schemas()) ::
  :ok | {:error, [{list(), term()}, ...]}

:ok, or every fault of the binding against a board's required sources and the feeds' schemas (spec/15 §4.3), each at [:cells, cell, :sources, slot] or under it, ordered by path:

• a required slot the binding does not bind is {:unbound, :binding, slot};
• for a bound slot whose contract is not empty, a feed with no schema is {:undescribed, feed} and a describe answering {:error, reason} is {:describe, feed, reason}; each attribute the schema does not give is {:missing_attribute, slot, field, key} under :requires, and each declared type it contradicts {:schema_type, field, declared, described} under :types — the reasons and words of Visualize.Chart.apply/2 (spec/14 §7.4);
• for a bound slot whose reads is not empty, each field its schema types as its scale cannot take is {:type_mismatch, slot, field, expected, given} at [:cells, cell | path], the read's path in the component (D-153); a schema wanted only for this is no fault where it cannot be had;
• a binding of a slot nothing requires is :not_required.

A slot whose contract and reads are empty is not looked up, and a feed is described at most once.

@spec check_types(t(), %{required(key()) => need()}, %{
  required(feed()) => Visualize.Chart.field_types()
}) :: :ok | {:error, [{list(), term()}, ...]}

:ok, or every field a bound slot's component reads through a scale whose known type the scale's kind cannot take (spec/15 §4.3, spec/14 §7.4, D-153): {:type_mismatch, slot, field, expected, given} at [:cells, cell | path], the read's path in the component, ordered by path.

types maps a feed to what is known of its fields: a Visualize.Data.Schema, or a map from field to type, as Visualize.Data.Table.column_types/1 reads it from a sample's rows. An unbound slot, and a feed the map does not hold, are not checked — that is check/3's to report.

iex> alias Visualize.Board.Binding
iex> binding = Binding.new(%{{:wave, :points} => :clock})
iex> required = %{
...>   {:wave, :points} => %{fields: [:t, :v], types: %{}, requires: %{},
...>     reads: [{[:marks, 0, :channels, :x], :t, :number}]}
...> }
iex> Binding.check_types(binding, required, %{clock: %{t: :time, v: :number}})
{:error,
 [{[:cells, "wave", :marks, 0, :channels, :x], {:type_mismatch, "points", "t", :number, :time}}]}

@spec fetch(t(), atom(), atom()) :: {:ok, feed()} | :error

The feed a cell's slot is bound to, or :error.

@spec new() :: t()

The empty binding.

@spec new(map() | [{key(), feed()}]) :: t()

A binding of a map, or a list, of {{cell, slot}, feed} pairs. Raises ArgumentError for a key that is not a pair of names, atoms or strings.

@spec pools(t(), %{required(feed()) => term()}) :: %{
  required(String.t()) => %{required(String.t()) => term()}
}

One pool per cell (spec/15 §4.4): %{cell => %{slot => source}} from the binding and the host's sources by feed. A slot whose feed has no source is left out, so application reports it unbound.

iex> binding = Visualize.Board.Binding.new(%{{:a, :primary} => :cpu, {:b, :primary} => :mem})
iex> Visualize.Board.Binding.pools(binding, %{cpu: [%{t: 1, v: 2}]})
%{"a" => %{"primary" => [%{t: 1, v: 2}]}}

@spec put(t(), atom(), atom(), feed()) :: t()

The binding with one cell's slot bound to a feed.