@spec base(atom_type()) :: atom_type()

The plain type under a member: the member itself if it is plain.

@spec build(atom_type(), [atom_type()]) :: [atom_type()]

The member that is the values of base less those of the negations, as a list of the one member, or none if it has no value ([]), or base alone if nothing is taken out.

iex> list = {:list, [:any, :null]}
iex> Feel.Type.Except.build(list, [{:list, [:number, :null]}])
[{:except, {:list, [:any, :null]}, [{:list, [:number, :null]}]}]
iex> Feel.Type.Except.build({:list, [:number]}, [{:list, [:number, :null]}])
[]
iex> Feel.Type.Except.build({:closed_context, %{"a" => [:number]}}, [{:closed_context, %{"b" => [:string]}}])
[{:closed_context, %{"a" => [:number]}}]

@spec context_plans(atom_type(), [atom_type()], pos_integer()) ::
  {:found, [plan()]} | :covered | :bound

The contexts of base that are in none of the negations, as at most limit plans, or :covered if there are none, or :bound if the search was cut before it knew (:covered is a proof, and so is each plan).

iex> base = {:closed_context, %{"a" => [:number], "b" => [:string]}}
iex> half = {:closed_context, %{"a" => [{:number, Feel.Type.NumberSet.interval(Decimal.new(0), Decimal.new(5))}], "b" => [:string]}}
iex> {:found, [plan]} = Feel.Type.Except.context_plans(base, [half], 1)
iex> Map.keys(plan)
["a"]
iex> Feel.Type.Except.context_plans(base, [base], 1)
:covered

@spec empty?(atom_type(), [atom_type()]) :: boolean()

Whether the values of base less those of the negations are shown to be none (see the module).

iex> list = {:list, [:number, :null]}
iex> Feel.Type.Except.empty?(list, [{:list, [:number, :null, :string]}])
true
iex> Feel.Type.Except.empty?({:list, [:number, :string]}, [{:list, [:number]}, {:list, [:string]}])
false

@spec extend(atom_type(), [atom_type()]) :: [atom_type()]

The member less some more plain types of its kind: build/2 of the negations it has and the new ones. The negations of a member are in normal form already, none within another, so only the new ones are compared with them and with each other, which for one more is as many looks as there are negations, and not as many as there are pairs of them: a dispatch on a name takes one more type out at each test, and there are as many tests as a source has room for.

iex> list = {:list, [:any, :null]}
iex> [member] = Feel.Type.Except.extend(list, [{:list, [:number, :null]}])
iex> Feel.Type.Except.extend(member, [{:list, [:string, :null]}]) == Feel.Type.Except.build(list, [{:list, [:number, :null]}, {:list, [:string, :null]}])
true

@spec family(Feel.Type.Union.member()) :: family() | nil

Whether a member is a type with parts of a family that :except is for.

@spec meet(atom_type(), atom_type()) :: [atom_type()]

The values in both of two members of one family (an intersection of two types is one type): the bases meet, and the negations of both are taken out.

iex> a = {:list, [:number, :string, :null]}
iex> b = {:list, [:number, :null]}
iex> Feel.Type.Except.meet(a, {:except, {:list, [:any, :null]}, [b]})
[{:except, {:list, [:number, :string, :null]}, [{:list, [:number, :null]}]}]

@spec minus(atom_type(), atom_type()) :: [atom_type()]

The values of the first that are not in the second: at most one member for the base of the second taken out, and one for each of its negations (a value that is in the second's base and in a negation of it is not in the second).

iex> list = {:list, [:any, :null]}
iex> number = {:list, [:number, :null]}
iex> Feel.Type.Except.minus(list, number)
[{:except, {:list, [:any, :null]}, [{:list, [:number, :null]}]}]
iex> Feel.Type.Except.minus(number, list)
[]

@spec negations(atom_type()) :: [atom_type()]

The types taken out of a member.

@spec range_plans(atom_type(), [atom_type()], pos_integer()) ::
  {:found, [{Feel.Type.Union.t(), Feel.Type.Union.t()}]} | :covered | :bound

The ways for a range of base to be in none of the negations, as at most limit pairs of types, one for each end: the values that the start can have and the values that the end can have. :covered if there are none, :bound if the negations are more than the search shares between two ends.

iex> base = {:range, [:number, :string]}
iex> Feel.Type.Except.range_plans(base, [{:range, [:number]}, {:range, [:string]}], 2)
{:found, [{[:number], [:string]}, {[:string], [:number]}]}
iex> Feel.Type.Except.range_plans(base, [{:range, [:number, :string]}], 1)
:covered

@spec subset?(atom_type(), atom_type()) :: boolean()

Whether every value of the first is in the second, as far as it is shown (minus/2 has no member left).

@spec top(family()) :: Feel.Type.Union.member()

The type of every value of the family.