stdlib: the FSharp.Core audit, and the effect-arrow bug it found

[simontreanor]

The audit pass that closes dogfooding finding #5 (see #34). Depends on nothing else; #50 (the import diagnostic) is independent.

Comparing the surface member by member against FSharp.Core turned up 21 additions — and one bug that matters more than all of them.

The bug

Every scheme with a multi-argument callback put the effect variable on every arrow. A function's latent effect lives on its innermost arrow (DESIGN §4), so an impure two-argument callback wants pure outside and io inside, while (b ->{e} a ->{e} b) demands one answer for both. Nothing effectful could ever unify, which silently made every such member pure-only:

extern log : int -> int = builtins.print
let step acc x =
    let shown = log x
    acc + x
let total = List.fold step 0 [1, 2]

Before: effect mismatch: cannot unify 'a -> 'b -> 'a with int -> int ->{io} int. List.fold could not print. After: it checks, and let pure on it correctly reports performs `io` .

Thirteen schemes across List, Seq, Set, Map, Option and Result now carry the effect on the innermost arrow alone — strictly more permissive, so nothing that compiled before stops. There's a test asserting one shape per module so it cannot regress.

The 21 members

Nearly all from internal asymmetry rather than F# parity:

• List (4): takeWhile dropWhile — Seq had them; plus sortByDescending (which sortBy and sortDescending implied) and countBy.
• Seq (9): empty distinctBy replicate get last sumBy max min reduce — all of which List already had.
• Set/Map (2): iter, which existed on List, Seq, Option and Result but neither of these.
• Option/Result (5): Option.forall/contains; Result.exists/forall/contains. forall passes on None and on Error — the empty case, as List.forall passes on [].
• Global (1): sign, the one F# global with no equivalent.

Two smaller finds while wiring it up

• Seq.empty lowered to a bare iter(), which is a TypeError, not an empty iterator. Now iter([]), with a test.
• My first sign used a num_vars entry on a plain type variable, which constrains nothing — sign "x" type-checked. The numeric constraint is the dedicated Ty::Num, as abs uses. Caught by its own test.

Deliberately not added: foldBack/reduceBack/scanBack (no reverse-order idiom here), transpose/permute/splitInto/allPairs/zip3 (niche), mapi (indexed plus a tuple parameter now covers it), singleton ([x]), Seq.cache (the single-pass caveat is documented rather than papered over).

Tests: 7 typecheck cases including the multi-argument-effect regression across all nine affected members, 2 lowering assertions, and an end-to-end program covering all 21. Full suite, clippy, fmt and the 23 doc lessons clean.