fix(beam): preserve function-value identity for PhysicalEquality

[dbrattli]

Problem

LanguagePrimitives.PhysicalEquality (and ReferenceEquals, and the <>/reference-identity patterns built on them) returned false for the same F# function value on the Beam target.

Fable-BEAM represents one logical function value with different Erlang funs depending on the argument site:

• Re-curried form (e.g. a function stored in a list/record): a nested 1-arity adapter fun(A0) -> fun(A1) -> F(A0, A1) end end, from a Curry node.
• Uncurried form (compared/passed to an uncurried slot): a single N-arity fun fun(A, B) -> F(A, B) end.

Erlang compares funs by closure identity, so these representations are never =:= even though they denote one value. Real-world symptom: removing a stored callback by reference identity (e.g. sinks |> List.filter (fun s -> not (PhysicalEquality s sink))) never matched, so nothing was removed.

Fix

Make the two adapter kinds identity-recoverable by tagging them, rather than changing the underlying function representation (which would ripple through the hand-written curried runtime libs).

• fable_utils:make_curry/2 — routed from the Curry node in Fable2Beam.fs. Builds the re-curried adapter but captures the underlying F inside a {fable_curry_adapter, F, N} marker as the outermost fun's only captured variable. Applies F with erlang:apply (all args at once), matching the default multi-arg lowering exactly, so it is behaviour-identical bar the marker.
• fable_utils:make_eta/2 — routed from the EtaAdapterDelegate pattern in Fable2Beam.fs. Same idea for the uncurried adapter, tagged {fable_eta_adapter, F, N}.
• fable_utils:fun_ref_eq/2 — peels either marker via erlang:fun_info(F, env) before =:=, normalising every representation of a value to the same F.
• Beam/Replacements.fs — route PhysicalEquality/ReferenceEquals through fun_ref_eq when either operand is a function type; keep plain =:= otherwise.

Precise reference identity, not structural equality. Only Fable's own compiler-generated adapters carry a marker, so a hand-written eta expansion (fun x -> g x) or a partial application is left intact and stays distinct — matching .NET. (An earlier iteration used a shape heuristic — unwrap any 1-arity fun capturing a single function — which wrongly collapsed fun x -> g x onto g; the marker approach fixes that false positive.)

Adapter cancellation (mirrors the Python target's curry.py memoization). If make_eta/make_curry receives a value that is already the opposite, same-arity adapter, it returns the original underlying fun instead of stacking a second wrapper (uncurry ∘ curry = curry ∘ uncurry = id). A round-tripped value is then the same fun object — native =:= holds with no unwrap and no per-call wrapper cost — and adapters never accumulate. The marker lives in the closure env, so unlike Python's process-local WeakKeyDictionary this survives a fun crossing process boundaries. The arity in the marker guards the cancellation (a mismatch wraps instead, avoiding badarity).

Known limitations (documented in Beam/FABLE-BEAM.md)

• Arity cap 2..7 (matching make_eta). Functions with 8+ curried args fall back to the default lowering and are not identity-preserved.
• Generic call sites: routing to fun_ref_eq is gated on the operand being a LambdaType/DelegateType at the call site. A value typed as a bare generic 'T (Fable does not monomorphise) falls back to plain =:=, so wrapping PhysicalEquality in a generic helper does not get the function-aware path.

Tests

New tests in tests/Beam/ComparisonTests.fs (pass on .NET first, then Beam):

• A curried 2-arg function stored in a list is found by reference identity; a distinct-but-identical function is not found.
• PhysicalEquality-based removal actually removes the stored element and is a no-op for a non-stored one (the sink-removal pattern), including a tuple-sourced sink stored/removed via a class.
• Identity, not structural equality: two distinct closures with identical bodies stay unequal, and a hand-written eta expansion (fun x -> g x) stays distinct from the original (regression guard for the former shape heuristic).

Full Beam suite: 2500 passed, 0 failed (.NET 2494, 0 failed).

Note: changelog files are auto-generated from commit history per AGENTS.md, so none is edited here.

🤖 Generated with Claude Code