Optimize List runtime representation with a stack

Author: alfonsogarciacaro

src/Fable.Transforms/Fable2Babel.fs

@@ -176,12 +176,6 @@ module Util =
         let entRef = Replacements.jsConstructor com ent
         com.TransformAsExpr(ctx, entRef)
 
-    let makeList com ctx headAndTail =
-        match headAndTail with
-        | None -> [||]
-        | Some(TransformExpr com ctx head, TransformExpr com ctx tail) -> [|head; tail|]
-        |> coreLibConstructorCall com ctx "Types" "List"
-
     // TODO: range
     let makeArray (com: IBabelCompiler) ctx exprs =
         List.mapToArray (fun e -> com.TransformAsExpr(ctx, e)) exprs
@@ -814,12 +808,12 @@ module Util =
         | Fable.NewTuple vals -> makeTypedArray com ctx Fable.Any (Fable.ArrayValues vals)
         // Optimization for bundle size: compile list literals as List.ofArray
         | Replacements.ListLiteral(exprs, t) ->
-            match exprs with
-            | [] -> makeList com ctx None
-            | [expr] -> Some(expr, Fable.Value(Fable.NewList (None,t), None)) |> makeList com ctx
-            | exprs -> [|makeArray com ctx exprs|] |> coreLibCall com ctx r "List" "ofArray"
+            [|List.rev exprs |> makeArray com ctx|] |> coreLibConstructorCall com ctx "Types" "List"
         | Fable.NewList (headAndTail, _) ->
-            makeList com ctx headAndTail
+            match headAndTail with
+            | None -> coreLibConstructorCall com ctx "Types" "List" [||]
+            | Some(TransformExpr com ctx head, TransformExpr com ctx tail) ->
+                coreLibCall com ctx None "Types" "newList" [|head; tail|]
         | Fable.NewOption (value, t) ->
             match value with
             | Some (TransformExpr com ctx e) ->
@@ -1217,9 +1211,9 @@ module Util =
             let op = if nonEmpty then BinaryUnequal else BinaryEqual
             upcast BinaryExpression(op, com.TransformAsExpr(ctx, expr), NullLiteral(), ?loc=range)
         | Fable.ListTest nonEmpty ->
-            let expr = com.TransformAsExpr(ctx, expr)
-            let op = if nonEmpty then BinaryUnequal else BinaryEqual
-            upcast BinaryExpression(op, get None expr "tail", NullLiteral(), ?loc=range)
+            let expr = get range (com.TransformAsExpr(ctx, expr)) "empty"
+            if nonEmpty then upcast UnaryExpression(UnaryNot, expr, ?loc=range)
+            else expr
         | Fable.UnionCaseTest(uci, ent) ->
             let expected = FSharp2Fable.Helpers.unionCaseTag ent uci |> ofInt
             let actual = com.TransformAsExpr(ctx, expr) |> getUnionExprTag None

src/fable-library/Types.ts

@@ -54,24 +54,60 @@ function compareList<T>(self: List<T>, other: List<T>) {
     if (other == null) {
       return -1;
     }
-    while (self.tail != null) {
-      if (other.tail == null) { return 1; }
-      const res = compare(self.head, other.head);
+    const idxDiff = self.idx - other.idx;
+    for (let i = self.idx; i >= 0; i--) {
+      let otherIdx = i - idxDiff;
+      if (otherIdx < 0) { return 1; }
+      const selfItem = self.vals[i];
+      const otherItem = other.vals[otherIdx];
+      const res = compare(selfItem, otherItem);
       if (res !== 0) { return res; }
-      self = self.tail;
-      other = other.tail;
     }
-    return other.tail == null ? 0 : -1;
+    return self.length === other.length ? 0 : -1;
   }
 }
 
+export function newList<T>(head: T, tail: List<T>): List<T> {
+  // If the tail points to the last index of the stack, push the new value into it.
+  // Otherwise, create a new stack
+  const vals = tail.vals.length === tail.idx + 1 ? tail.vals : tail.vals.slice(0, tail.idx + 1);
+  vals.push(head);
+  const li = new List(vals);
+  li._tail = tail;
+  return li;
+}
+
+/**
+ * F# list is represented in runtime by an optimized type that uses a stack (a reverted JS array)
+ * to store the values, so we can a have a big list represented by a single object (plus the stack).
+ * It also allows for optimizations in the List module.
+ */
 export class List<T> implements IEquatable<List<T>>, IComparable<List<T>>, Iterable<T> {
-  public head: T;
-  public tail?: List<T>;
+  public vals: T[];
+  public idx: number;
+  public _tail: List<T> | undefined;
+
+  constructor(vals?: T[], idx?: number) {
+    this.vals = vals ?? [];
+    this.idx = idx ?? this.vals.length - 1;
+  }
+
+  public get empty() {
+    return this.idx < 0;
+  }
+
+  public get head(): T | undefined {
+    return this.vals[this.idx];
+  }
 
-  constructor(head?: T, tail?: List<T>) {
-    this.head = head as T;
-    this.tail = tail;
+  public get tail(): List<T> | undefined {
+    return !this.empty
+      ? this._tail ?? (this._tail = new List(this.vals, this.idx - 1))
+      : undefined;
+  }
+
+  public get length() {
+    return this.idx + 1;
   }
 
   public toString() {
@@ -83,20 +119,25 @@ export class List<T> implements IEquatable<List<T>>, IComparable<List<T>>, Itera
   }
 
   public [Symbol.iterator](): Iterator<T> {
-    let cur: List<T> | undefined = this;
+    let curIdx = this.idx;
     return {
-      next: (): IteratorResult<T> => {
-        const value = cur?.head as T;
-        const done = cur?.tail == null;
-        cur = cur?.tail;
-        return { done, value };
-      },
+      next: () => ({
+        done: curIdx < 0,
+        value: this.vals[curIdx--],
+      }),
     };
   }
 
   public GetHashCode() {
-    const hashes = Array.from(this).map(structuralHash);
-    return combineHashCodes(hashes);
+    if (this.idx < 0) {
+      return 0;
+    } else {
+      const hashes: number[] = new Array(this.idx + 1);
+      for (let i = this.idx; i >= 0; i--) {
+        hashes[i] = structuralHash(this.vals[i]);
+      }
+      return combineHashCodes(hashes);
+    }
   }
 
   public Equals(other: List<T>): boolean {