@fable-org/fable-library-ts 2.4.0 → 2.4.1

package/BigInt.ts

@@ -135,12 +135,12 @@ export function toIntN_unchecked(bits: number, x: bigint, signed: boolean): bigi
 }
 
 export function toIntN(bits: number, x: bigint, signed: boolean): bigint {
-    let higher_bits = abs(x) >> BigInt(bits);
-    if (higher_bits !== 0n) {
+    const truncated = signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+    if (truncated !== x) {
         const s = signed ? "a signed" : "an unsigned";
         throw new Exception(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
     }
-    return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
+    return truncated;
 }
 
 export function toInt8(x: bigint): int8 { return Number(toIntN(8, x, true)); }
@@ -176,6 +176,9 @@ export function toFloat64(x: bigint): float64 { return Number(x); }
 export function toDecimal(x: bigint): decimal {
     const isNegative = x < zero;
     const bits = abs(x);
+    if ((bits >> 96n) !== zero) {
+        throw new Exception("Value was either too large or too small for a Decimal.");
+    }
     const low = Number(BigInt.asUintN(32, bits));
     const mid = Number(BigInt.asUintN(32, bits >> 32n));
     const high = Number(BigInt.asUintN(32, bits >> 64n));
@@ -228,6 +231,8 @@ export function divRem(x: bigint, y: bigint, out?: FSharpRef<bigint>): bigint |
 }
 
 export function greatestCommonDivisor(x: bigint, y: bigint): bigint {
+    x = abs(x);
+    y = abs(y);
     while (y > zero) {
         const q = x / y;
         const r = x - q * y;
@@ -237,8 +242,17 @@ export function greatestCommonDivisor(x: bigint, y: bigint): bigint {
     return x;
 }
 
+// Number of bits in the binary representation of x (x must be positive)
+function bitLength(x: bigint): number {
+    const hex = x.toString(16);
+    return (hex.length - 1) * 4 + (32 - Math.clz32(fromHexCode(hex.charCodeAt(0))));
+}
+
 export function getBitLength(x: bigint): int64 {
-    return fromFloat64(x === zero ? 1 : log2(abs(x)) + 1);
+    if (x < zero) {
+        x = -x - one; // two's complement bit length excluding the sign bit
+    }
+    return x === zero ? zero : BigInt(bitLength(x));
 }
 
 export function log2(x: bigint): float64 {
@@ -274,7 +288,10 @@ export function log(x: bigint, base: float64): float64 {
 }
 
 export function ilog2(x: bigint): bigint {
-    return BigInt(log2(x));
+    if (x < zero) {
+        throw new Exception("Value must be non-negative.");
+    }
+    return x === zero ? zero : BigInt(bitLength(x) - 1);
 }
 
 // export function copySign
@@ -305,35 +322,20 @@ function fromHexCode(code: number): number {
 
 function toSignedBytes(x: bigint, isBigEndian: boolean): Uint8Array {
     const isNeg = x < 0n;
-    if (isNeg) {
-        const len = log2(-x);
-        const bits = len + (8 - len % 8);
-        const pow2 = (1n << BigInt(bits));
-        x = x + pow2; // two's complement
-    }
-    const hex = x.toString(16);
-    const len = hex.length;
-    const odd = len % 2;
-    const first = hex.charCodeAt(0);
-    const isLow = 48 <= first && first <= 55; // 0..7
-    const start = (isNeg && isLow) || (!isNeg && !isLow) ? 1 : 0;
-    const bytes = new Uint8Array(start + (len + odd) / 2);
-    const inc = isBigEndian ? 1 : -1;
-    let pos = isBigEndian ? 0 : bytes.length - 1;
-    if (start > 0) {
-        bytes[pos] = isNeg ? 255 : 0;
-        pos += inc;
-    }
-    if (odd > 0) {
-        bytes[pos] = fromHexCode(first);
-        pos += inc;
+    const sentinel = isNeg ? -1n : 0n;
+    const bytes: number[] = []; // little-endian
+    do {
+        bytes.push(Number(BigInt.asUintN(8, x)));
+        x = x >> 8n;
+    } while (x !== sentinel);
+    // extra byte if the top byte's sign bit would misrepresent the sign
+    if (isNeg !== (bytes[bytes.length - 1] > 127)) {
+        bytes.push(isNeg ? 255 : 0);
     }
-    for (let i = odd; i < len; i += 2, pos += inc) {
-        const a = fromHexCode(hex.charCodeAt(i));
-        const b = fromHexCode(hex.charCodeAt(i + 1));
-        bytes[pos] = (a << 4) | b;
+    if (isBigEndian) {
+        bytes.reverse();
     }
-    return bytes;
+    return new Uint8Array(bytes);
 }
 
 function fromSignedBytes(bytes: ArrayLike<uint8>, isBigEndian: boolean) {

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: 7f915f1dd66b9a5fbbd56f858b07d39b98519b65
+last_commit_released: d6ae6bd3790b57b31941a118cdffaeb6a59155c3
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 2.4.1 - 2026-07-09
+
+### 🐞 Bug Fixes
+
+* MailboxProcessor dropping falsy messages and unit replies ([8299b2e7](https://github.com/fable-compiler/Fable/commit/8299b2e7f690e9136906653155883a08607aa4a4))
+* *(all)* Add `Seq.enumerateTryWith` for try/with in seq, list, array comprehensions (#4750) ([448c90d7](https://github.com/fable-compiler/Fable/commit/448c90d7ccba80ee3d3c38432a2a1d1407f6dc69))
+* *(js/ts)* Match .NET NaN semantics in JS comparison, min and max ([7e5106f9](https://github.com/fable-compiler/Fable/commit/7e5106f9d93cb55ae4aca4656868fa0c53493991))
+* *(js/ts)* BigInteger byte-array corruption, checked conversions, gcd, log2 (#4743) ([f3cb7f2b](https://github.com/fable-compiler/Fable/commit/f3cb7f2bfc9e46e558763867d6c1ba323bcf281c))
+* *(js/ts)* Observable/Event dropping null/undefined/unit values (#4742) ([75bff73b](https://github.com/fable-compiler/Fable/commit/75bff73be3743fe0af37f99c541b10f6978150f3))
+* *(js/ts)* EndsWith regression for empty pattern with non-ordinal comparison ([7793ed7b](https://github.com/fable-compiler/Fable/commit/7793ed7b0fc1f33bf3da6c0ea31607e172726267))
+* *(js/ts/python)* Quote strings with the %A format specifier (#4749) ([75321f3b](https://github.com/fable-compiler/Fable/commit/75321f3b2cb70ea345a0a45d6343cbb6e0de466f))
+* *(ts/js)* `Regex.Replace` count/substitutions and `Regex.Split` semantics (#4741) ([d6ae6bd3](https://github.com/fable-compiler/Fable/commit/d6ae6bd3790b57b31941a118cdffaeb6a59155c3))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/7f915f1dd66b9a5fbbd56f858b07d39b98519b65..d6ae6bd3790b57b31941a118cdffaeb6a59155c3)</small></strong>
+
 ## 2.4.0 - 2026-07-05
 
 ### 🚀 Features

package/Double.ts

@@ -36,18 +36,20 @@ export function isInfinity(x: number) {
 }
 
 export function max(x: number, y: number): number {
-  return x > y ? x : y;
+  return Math.max(x, y);
 }
 
 export function min(x: number, y: number): number {
-  return x < y ? x : y;
+  return Math.min(x, y);
 }
 
 export function maxMagnitude(x: number, y: number): number {
+  if (Number.isNaN(x) || Number.isNaN(y)) { return NaN; }
   return Math.abs(x) > Math.abs(y) ? x : y;
 }
 
 export function minMagnitude(x: number, y: number): number {
+  if (Number.isNaN(x) || Number.isNaN(y)) { return NaN; }
   return Math.abs(x) < Math.abs(y) ? x : y;
 }
 

package/Event.ts

@@ -35,8 +35,16 @@ export class Event$2<Delegate extends Function, Args> {
   public Trigger(value: Args): void;
   public Trigger(sender: any, value: Args): void
   public Trigger(senderOrValue: any, valueOrUndefined?: Args): void {
+    // Disambiguate the overloads by arity, not by value: a two-argument call may
+    // legitimately pass `undefined` as the event value (e.g. unit events).
     let sender: any = null;
-    const value = valueOrUndefined === undefined ? senderOrValue as Args : (sender = senderOrValue, valueOrUndefined);
+    let value: Args;
+    if (arguments.length <= 1) {
+      value = senderOrValue as Args;
+    } else {
+      sender = senderOrValue;
+      value = valueOrUndefined as Args;
+    }
     this.delegates.forEach(f => { f(sender, value) });
   }
 }

package/List.ts

@@ -1,9 +1,8 @@
 
-import { join } from "./String.ts";
+import { IComparer, IEqualityComparer, isArrayLike, MutableArray, Exception, defaultOf, toIterator, compare, structuralHash, equals, IDisposable, disposeSafe, IEnumerator, getEnumerator } from "./Util.ts";
+import { Record, toString } from "./Types.ts";
 import { defaultArg, some, value as value_1, Option } from "./Option.ts";
-import { IComparer, IEqualityComparer, disposeSafe, isArrayLike, MutableArray, Exception, IDisposable, defaultOf, toIterator, getEnumerator, IEnumerator, compare, structuralHash, equals } from "./Util.ts";
 import { float64, int32 } from "./Int32.ts";
-import { Record } from "./Types.ts";
 import { class_type, record_type, option_type, TypeInfo } from "./Reflection.ts";
 import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.ts";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
@@ -20,7 +19,21 @@ export class FSharpList<T> extends Record implements Iterable<T> {
     }
     toString(): string {
         const xs: FSharpList<T> = this;
-        return ("[" + join("; ", xs)) + "]";
+        let result = "[";
+        let first = true;
+        const enumerator: IEnumerator<T> = getEnumerator(xs);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let x: T = (undefined as any), matchValue: any = (undefined as any), s: string = (undefined as any);
+                const x_1: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                result = ((first ? result : (result + "; ")) + ((x = x_1, (matchValue = x, (typeof matchValue === "string") ? ((s = (matchValue as string), ("\"" + s) + "\"")) : toString(x)))));
+                first = false;
+            }
+        }
+        finally {
+            disposeSafe(enumerator as IDisposable);
+        }
+        return result + "]";
     }
     Equals(other: any): boolean {
         const xs: FSharpList<T> = this;

package/MailboxProcessor.ts

@@ -28,7 +28,7 @@ class MailboxQueue<Msg> {
     }
   }
 
-  public tryGet() {
+  public tryGet(): { value: Msg } | undefined {
     if (this.firstAndLast) {
       const value = this.firstAndLast[0].value;
       if (this.firstAndLast[0].next) {
@@ -36,7 +36,9 @@ class MailboxQueue<Msg> {
       } else {
         delete this.firstAndLast;
       }
-      return value;
+      // Wrap the value so falsy messages (0, false, "", null, undefined/unit)
+      // can be distinguished from an empty queue.
+      return { value };
     }
     return void 0;
   }
@@ -64,11 +66,11 @@ export class MailboxProcessor<Msg> {
 
 function __processEvents<Msg>($this: MailboxProcessor<Msg>) {
   if ($this.continuation) {
-    const value = $this.messages.tryGet();
-    if (value) {
+    const dequeued = $this.messages.tryGet();
+    if (dequeued !== void 0) {
       const cont = $this.continuation;
       delete $this.continuation;
-      cont(value);
+      cont(dequeued.value);
     }
   }
 }
@@ -97,15 +99,19 @@ export function postAndAsyncReply<Reply, Msg>(
   buildMessage: (c: AsyncReplyChannel<Reply>) => Msg,
 ) {
   let result: Reply;
+  // Use an explicit flag because the reply value itself may be undefined
+  // (e.g. AsyncReplyChannel<unit>), which must still complete the async.
+  let replied = false;
   let continuation: Continuation<Reply>;
   function checkCompletion() {
-    if (result !== void 0 && continuation !== void 0) {
+    if (replied && continuation !== void 0) {
       continuation(result);
     }
   }
   const reply = {
     reply: (res: Reply) => {
       result = res;
+      replied = true;
       checkCompletion();
     },
   };

package/Observable.ts

@@ -1,6 +1,6 @@
 
 import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.ts";
-import { Option, value } from "./Option.ts";
+import { Option, some, value } from "./Option.ts";
 import { IDisposable } from "./Util.ts";
 
 export interface IObserver<T> {
@@ -56,7 +56,7 @@ export function choose<T, U>(chooser: (x: T) => Option<U>, source: IObservable<T
 }
 
 export function filter<T>(predicate: (x: T) => boolean, source: IObservable<T>): IObservable<T> {
-  return choose((x) => predicate(x) ? x : void 0, source);
+  return choose((x) => predicate(x) ? some(x) : undefined, source);
 }
 
 export function map<T, U>(mapping: (x: T) => U, source: IObservable<T>): IObservable<U> {
@@ -120,11 +120,13 @@ export function merge<T>(source1: IObservable<T>, source2: IObservable<T>): IObs
 export function pairwise<T>(source: IObservable<T>): IObservable<[T, T]> {
   return new Observable<[T, T]>((observer) => {
     let last: T;
+    let haveLast = false;
     return source.Subscribe(new Observer<T>((next) => {
-      if (last != null) {
+      if (haveLast) {
         observer.OnNext([last, next]);
       }
       last = next;
+      haveLast = true;
     }, observer.OnError, observer.OnCompleted));
   });
 }

package/RegExp.ts

@@ -117,28 +117,32 @@ export function replace(
     input = tmp;
     limit = undefined;
   }
-  if (typeof replacement === "function") {
-    limit = limit == null ? -1 : limit;
-    return input.substring(0, offset) + input.substring(offset).replace(reg as RegExp, replacer);
-  } else {
-    replacement =
-      replacement
-      // $0 doesn't work with JS regex, see #1155
-      .replace(/\$0/g, (_s) => "$&")
-      // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)
-      .replace(/\${([^}]+)}/g, "\$<$1>")
-      ;
-    if (limit != null) {
-      let m: RegExpExecArray;
-      const sub1 = input.substring(offset);
-      const _matches = matches(reg, sub1);
-      const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;
-      return input.substring(0, offset) + sub2.replace(reg as RegExp, replacement as string)
-        + input.substring(offset + sub2.length);
-    } else {
-      return input.replace(reg as RegExp, replacement as string);
-    }
+  if (typeof replacement === "string") {
+    const rep = replacement as string;
+    // .NET replacement patterns cannot be rewritten as JS replacement strings unambiguously
+    // (e.g. `$$0` must stay literal "$0", `$0` doesn't work with JS regex (see #1155), and
+    // `${1}` followed by a digit must not become `$1` + digit), so interpret them with an
+    // evaluator instead, honoring the `$$` escape left-to-right
+    replacement = (match: any): string =>
+      rep.replace(/\$(?:(\$)|(&)|(`)|(')|(\d+)|\{(\d+)\}|\{([^}]+)\})/g,
+        (s, dollar?: string, and?: string, before?: string, after?: string, num?: string, numBraced?: string, name?: string) => {
+          if (dollar != null) { return "$"; }
+          if (and != null) { return match[0]; }
+          if (before != null) { return match.input.substring(0, match.index); }
+          if (after != null) { return match.input.substring(match.index + match[0].length); }
+          const n = num ?? numBraced;
+          if (n != null) {
+            const i = parseInt(n, 10);
+            // Same as .NET: an unmatched group is replaced by an empty string,
+            // a nonexistent group number keeps the substitution pattern literally
+            return i < match.length ? (match[i] ?? "") : s;
+          }
+          // Named groups are `${name}` in .NET (in regex: groups are `(?<name>...)` in both)
+          return match.groups != null && (name as string) in match.groups ? (match.groups[name as string] ?? "") : s;
+        });
   }
+  limit = limit == null ? -1 : limit;
+  return input.substring(0, offset) + input.substring(offset).replace(reg as RegExp, replacer);
 }
 
 export function split(reg: string | RegExp, input: string, limit?: number, offset: number = 0) {
@@ -148,6 +152,26 @@ export function split(reg: string | RegExp, input: string, limit?: number, offse
     input = tmp;
     limit = undefined;
   }
-  input = input.substring(offset);
-  return input.split(reg as RegExp, limit);
+  // JS String.split(regex, limit) truncates the result and discards the remainder,
+  // whereas .NET keeps it in the last element (`limit` is the max number of elements),
+  // keeps the text before `offset` in the first element and includes the values of
+  // matched capture groups, so iterate the matches manually like .NET Regex.Split does
+  const result: string[] = [];
+  let prev = 0;
+  let count = limit == null ? -1 : limit - 1;
+  for (const m of matches(reg as RegExp, input, offset)) {
+    if (count === 0) {
+      break;
+    }
+    result.push(input.substring(prev, m.index));
+    prev = m.index + m[0].length;
+    for (let i = 1; i < m.length; i++) {
+      if (m[i] !== undefined) {
+        result.push(m[i]);
+      }
+    }
+    count--;
+  }
+  result.push(input.substring(prev));
+  return result;
 }

package/Seq.ts

@@ -508,6 +508,94 @@ export function enumerateWhile<T>(guard: (() => boolean), xs: Iterable<T>): Iter
     return concat<Iterable<T>, T>(unfold<int32, Iterable<T>>((i: int32): Option<[Iterable<T>, int32]> => (guard() ? ([xs, i + 1] as [Iterable<T>, int32]) : undefined), 0));
 }
 
+export function enumerateTryWith<T>(source: Iterable<T>, catchFilter: ((arg0: Exception) => int32), catchHandler: ((arg0: Exception) => Iterable<T>)): Iterable<T> {
+    return mkSeq<T>((): IEnumerator<T> => {
+        let e: Option<IEnumerator<T>> = undefined;
+        let caught = false;
+        let started = false;
+        let finished = false;
+        let curr: Option<T> = undefined;
+        const tryNext = (): boolean => {
+            try {
+                let en_2: IEnumerator<T>;
+                if (e == null) {
+                    const en_1: IEnumerator<T> = getEnumerator(source);
+                    e = en_1;
+                    en_2 = en_1;
+                }
+                else {
+                    en_2 = value_1(e);
+                }
+                if (en_2["System.Collections.IEnumerator.MoveNext"]()) {
+                    curr = some(en_2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+                    return true;
+                }
+                else {
+                    finished = true;
+                    return false;
+                }
+            }
+            catch (matchValue: any) {
+                if (!caught) {
+                    const ex_1: Exception = matchValue;
+                    if (catchFilter(ex_1) !== 0) {
+                        caught = true;
+                        if (e == null) {
+                        }
+                        else {
+                            const en_3: IEnumerator<T> = value_1(e);
+                            try {
+                                disposeSafe(en_3);
+                            }
+                            catch (matchValue_1: any) {
+                            }
+                            e = undefined;
+                        }
+                        e = getEnumerator(catchHandler(ex_1));
+                        return tryNext();
+                    }
+                    else {
+                        throw matchValue;
+                    }
+                }
+                else {
+                    throw matchValue;
+                }
+            }
+        };
+        return Enumerator_FromFunctions$1_$ctor_58C54629<T>((): T => {
+            if (!started) {
+                Enumerator_notStarted<void>();
+            }
+            else if (finished) {
+                Enumerator_alreadyFinished<void>();
+            }
+            if (curr != null) {
+                return value_1(curr);
+            }
+            else {
+                return Enumerator_alreadyFinished<T>();
+            }
+        }, (): boolean => {
+            if (!started) {
+                started = true;
+            }
+            if (finished) {
+                return false;
+            }
+            else {
+                return tryNext();
+            }
+        }, (): void => {
+            if (e == null) {
+            }
+            else {
+                disposeSafe(value_1(e));
+            }
+        });
+    });
+}
+
 export function filter<T>(f: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T> {
     return choose<T, T>((x: T): Option<T> => {
         if (f(x)) {

package/Set.ts

@@ -3,10 +3,9 @@ import { record_type, bool_type, list_type, option_type, class_type, TypeInfo }
 import { some, value as value_2, Option } from "./Option.ts";
 import { int32 } from "./Int32.ts";
 import { structuralHash, ISet, toIterator, IDisposable, disposeSafe, getEnumerator, isArrayLike, MutableArray, IEnumerator, IComparer, Exception } from "./Util.ts";
-import { Record } from "./Types.ts";
+import { toString, Record } from "./Types.ts";
 import { fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1, FSharpList } from "./List.ts";
 import { fold as fold_1, fill, setItem } from "./Array.ts";
-import { join } from "./String.ts";
 import { NotSupportedException_$ctor_Z721C83C5 } from "./System.ts";
 import { skip, truncate, iterateIndexed, exists as exists_1, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from "./Seq.ts";
 import { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from "./MutableSet.ts";
@@ -1495,7 +1494,21 @@ export class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
     }
     toString(): string {
         const this$: FSharpSet<T> = this;
-        return ("set [" + join("; ", this$)) + "]";
+        let result = "set [";
+        let first = true;
+        const enumerator: IEnumerator<T> = getEnumerator(this$);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let x: T = (undefined as any), matchValue: any = (undefined as any), s: string = (undefined as any);
+                const x_1: T = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                result = ((first ? result : (result + "; ")) + ((x = x_1, (matchValue = x, (typeof matchValue === "string") ? ((s = (matchValue as string), ("\"" + s) + "\"")) : toString(x)))));
+                first = false;
+            }
+        }
+        finally {
+            disposeSafe(enumerator as IDisposable);
+        }
+        return result + "]";
     }
     get [Symbol.toStringTag](): string {
         return "FSharpSet";

package/String.ts

@@ -81,7 +81,7 @@ export function endsWith(str: string, pattern: string, ic: boolean | StringCompa
     return str.endsWith(pattern);
   }
   if (str.length >= pattern.length) {
-    return cmp(str.slice(-pattern.length), pattern, ic) === 0;
+    return cmp(str.slice(str.length - pattern.length), pattern, ic) === 0;
   }
   return false;
 }
@@ -253,6 +253,8 @@ function formatReplacement(rep: any, flags: any, padLength: any, precision: any,
     }
   } else if (rep instanceof Date) {
     rep = dateToString(rep);
+  } else if (format === "A" && typeof rep === "string") {
+    rep = "\"" + rep + "\"";
   } else {
     rep = toString(rep);
   }

package/Types.ts

@@ -9,18 +9,25 @@ export function seqToString<T>(self: Iterable<T>): string {
   let str = "[";
   for (const x of self) {
     if (count === 0) {
-      str += toString(x);
+      str += toStringQuoted(x);
     } else if (count === 100) {
       str += "; ...";
       break;
     } else {
-      str += "; " + toString(x);
+      str += "; " + toStringQuoted(x);
     }
     count++;
   }
   return str + "]";
 }
 
+// Structured (%A-style) rendering of a value used as an element/field of a
+// container. F#'s structured formatting (which records, unions, lists, etc.
+// use in their ToString) quotes strings, e.g. `["a"; "b"]` and `{ Name = "John" }`.
+function toStringQuoted(x: any, callStack = 0): string {
+  return typeof x === "string" ? "\"" + x + "\"" : toString(x, callStack);
+}
+
 export function toString(x: any, callStack = 0): string {
   if (x != null && typeof x === "object") {
     if (typeof x.toString === "function" && x.toString !== Object.prototype.toString) {
@@ -31,7 +38,7 @@ export function toString(x: any, callStack = 0): string {
       const cons = Object.getPrototypeOf(x)?.constructor;
       return cons === Object && callStack < 10
         // Same format as recordToString
-        ? "{ " + Object.entries(x).map(([k, v]) => k + " = " + toString(v, callStack + 1)).join("\n  ") + " }"
+        ? "{ " + Object.entries(x).map(([k, v]) => k + " = " + toStringQuoted(v, callStack + 1)).join("\n  ") + " }"
         : cons?.name ?? "";
     }
   }
@@ -39,23 +46,16 @@ export function toString(x: any, callStack = 0): string {
 }
 
 export function unionToString(name: string, fields: any[]) {
-  function unionFieldToString(x: any): string {
-    if (typeof x === "string") {
-      return '"' + x + '"';
-    }
-    return toString(x);
-  }
-
   if (fields.length === 0) {
     return name;
   } else {
     let fieldStr;
     let withParens = true;
     if (fields.length === 1) {
-      fieldStr = unionFieldToString(fields[0]);
+      fieldStr = toStringQuoted(fields[0]);
       withParens = fieldStr.indexOf(" ") >= 0;
     } else {
-      fieldStr = fields.map((x: any) => unionFieldToString(x)).join(", ");
+      fieldStr = fields.map((x: any) => toStringQuoted(x)).join(", ");
     }
     return name + (withParens ? " (" : " ") + fieldStr + (withParens ? ")" : "");
   }
@@ -119,7 +119,7 @@ function recordToJSON<T>(self: T) {
 }
 
 function recordToString<T>(self: T) {
-  return "{ " + Object.entries(self as any).map(([k, v]) => k + " = " + toString(v)).join("\n  ") + " }";
+  return "{ " + Object.entries(self as any).map(([k, v]) => k + " = " + toStringQuoted(v)).join("\n  ") + " }";
 }
 
 function recordGetHashCode<T>(self: T) {

package/Util.ts

@@ -564,7 +564,12 @@ export function compareDates(x: Date | IDateTime | IDateTimeOffset, y: Date | ID
 }
 
 export function comparePrimitives<T>(x: T, y: T): number {
-  return x === y ? 0 : (x < y ? -1 : 1);
+  if (x === y) { return 0; }
+  if (x < y) { return -1; }
+  if (x > y) { return 1; }
+  // Neither equal nor ordered: at least one operand is NaN.
+  // Match .NET Double.CompareTo: NaN equals NaN and is less than any other value.
+  return Number.isNaN(x as unknown) ? (Number.isNaN(y as unknown) ? 0 : -1) : 1;
 }
 
 export function compareArraysWith<T>(x: ArrayLike<T>, y: ArrayLike<T>, comp: (x: T, y: T) => number): number {
@@ -616,7 +621,7 @@ export function compare<T>(x: T, y: T): number {
   } else if (isArrayLike(x)) {
     return isArrayLike(y) ? compareArrays(x, y) : -1;
   } else if (typeof x !== "object") {
-    return x < y ? -1 : 1;
+    return comparePrimitives(x, y);
   } else if (x instanceof Date) {
     return y instanceof Date ? compareDates(x, y) : -1;
   } else {

package/package.json

@@ -3,7 +3,7 @@
     "private": false,
     "type": "module",
     "name": "@fable-org/fable-library-ts",
-    "version": "2.4.0",
+    "version": "2.4.1",
     "description": "Core library used by F# projects compiled with fable.io",
     "author": "Fable Contributors",
     "license": "MIT",