A value compared with itself (D-170): x = x is true and x != x is false, for every value of FEEL, null included.

Feel.Runtime.Compare.equal/2 has no shortcut for two values that are the same one: it walks lists and contexts element by element. A value that is built from itself ({a0: [1, 2], a1: [a0, a0], …, a22: [a21, a21]}) is 23 cells in the VM and 2^22 numbers when it is walked, so a22 = a22 was ten seconds of one step, that no limit saw. An operand that is read twice is the same value both times, so the answer is known without reading it. The order of <, <=, > and >= is not an identity (null < null is null, and true <= true is null), so it is not the constant: ordering/4 has the type that the same read gives for the kinds that have an order (D-170).

Two operands are the same read when they are the same node, but for its meta:

• a constant that is the same term, or a name of the bindings ({:var, _, name}) with the same name;
• a :local of the same name and the same depth (meta.id, D-193), which is the binding of one construct;
• a selection by the same name (p.a, not p.(a)) from the same read;
• a list of the same length of the same reads, if the run can make it (max_list_length);
• a context literal with the same keys in the same order, of the same reads, that is not an error (D-58).

A call is never one, whatever it is called with: it is counted by max_calls and by the diagnostics, and now() and uuid() give another value the second time. Nor is anything that binds a name inside the operand (an iterator, a function), a filter, an item, a partial, a descendant, or an operation: when in doubt, the comparison is made.

And only for values of FEEL. A name of type Any can be bound to a term that is not one (a float, an atom, a decimal that is a NaN: Feel.Runtime.Kind.of/1 is :unknown for it, and x = x is null with a type mismatch), and the soundness sweeps run the analysis on such values (scripts/sweep/dispatch.exs). So the type of the operand has to say that every value of it is a value of FEEL: no Any, no :foreign, and no name of a model type in it, at any depth. A type that is too large to look through (a tower of contexts) is not looked through, and the comparison is made. A list and a context, open or closed, are values of FEEL whatever their elements and entries are: Compare.equal/2 answers true for a list or a context that is the same term before it looks at an element or an entry (D-168), so a p that is a declared context and has an entry of any kind, and an xs of list<Any> that holds a float, are equal to themselves (D-170). A range is walked, and its ends are looked at.

What the comparison tells depends on whether the reads can report:

• silent: constants, locals, the lists and the contexts of them, and a selection from a silent read whose type has no null in it (a selection reports an error only where it gives null). The two reads settle nothing and report nothing, so the comparison is the constant ({:const, _, true}).
• reads: a name of the bindings, which reports a name that is not bound (D-37) at each of the two reads, and what is built on it. The type of the comparison is true and the node stays, so that the run reports what it did (D-45, D-53).

What it does not see: two operands that are alike but are not the same read (a22 = b22 for two towers built apart, xs[1] = xs[1]), and the same value that comes from two calls. They are compared by the run.

iex> {:ok, ast} = Feel.parse("{a: [1, 2], b: [a, a], r: b = b}")
iex> {:ok, %{ir: {:context, _, entries}}} = Feel.Analysis.Analyzer.analyze(ast, [])
iex> {"r", {:const, %{type: type}, value}} = List.last(entries)
iex> {type, value}
{[{:boolean, true}], true}