Array-based List type

Author: ncave

.vscode/launch.json

@@ -124,8 +124,9 @@
             "args": [
                 "--no-timeouts",
                 "--colors",
+                "-r", "esm",
                 // "${workspaceFolder}/src/fable-standalone/test/bench-compiler/out-tests"
-                "${workspaceFolder}/build/tests"
+                "${workspaceFolder}/tests/Main"
             ],
             "internalConsoleOptions": "openOnSessionStart"
         },

src/Fable.Transforms/FSharp2Fable.Util.fs

@@ -264,7 +264,6 @@ module Helpers =
         then [||] :> IList<_>
         else (nonAbbreviatedType t).GenericArguments
 
-
     let private getEntityMangledName (com: Compiler) trimRootModule (ent: Fable.Entity) =
         match ent.FullName with
         | fullName when not trimRootModule -> fullName
@@ -1168,7 +1167,6 @@ module Util =
             | "System.IObservable`1"
             | "System.IObserver`1"
             | Types.ienumerableGeneric
-            | Types.ienumerator
             // These are used for injections
             | Types.comparer
             | Types.equalityComparer -> false

src/Fable.Transforms/Fable2Babel.fs

@@ -439,7 +439,7 @@ module Annotation =
             makeNativeTypeAnnotation com ctx [genArg] "Array"
 
     let makeListTypeAnnotation com ctx genArg =
-        makeImportTypeAnnotation com ctx [genArg] "Types" "List"
+        makeImportTypeAnnotation com ctx [genArg] "List" "List"
 
     let makeUnionTypeAnnotation com ctx genArgs =
         List.map (typeAnnotation com ctx) genArgs
@@ -658,12 +658,6 @@ module Util =
         | [] -> expr
         | m::ms -> get None expr m |> getParts ms
 
-    let makeList com ctx r headAndTail =
-        match headAndTail with
-        | None -> [||]
-        | Some(TransformExpr com ctx head, TransformExpr com ctx tail) -> [|head; tail|]
-        |> libConsCall com ctx r "Types" "List"
-
     let makeArray (com: IBabelCompiler) ctx exprs =
         List.mapToArray (fun e -> com.TransformAsExpr(ctx, e)) exprs
         |> ArrayExpression :> Expression
@@ -896,12 +890,17 @@ module Util =
         | Fable.NewTuple vals -> makeArray com ctx vals
         // Optimization for bundle size: compile list literals as List.ofArray
         | Replacements.ListLiteral(exprs, t) ->
-            match exprs with
-            | [] -> makeList com ctx r None
-            | [expr] -> Some(expr, Fable.Value(Fable.NewList (None,t), None)) |> makeList com ctx r
-            | exprs -> [|makeArray com ctx exprs|] |> libCall com ctx r "List" "ofArray"
+            [|List.rev exprs |> makeArray com ctx|]
+            |> libCall com ctx r "List" "newList"
+            // match exprs with
+            // | [] -> libCall com ctx r "List" "empty" [||]
+            // | [TransformExpr com ctx expr] -> libCall com ctx r "List" "singleton" [|expr|]
+            // | exprs -> [|makeArray com ctx exprs|] |> libCall com ctx r "List" "ofArray"
         | Fable.NewList (headAndTail, _) ->
-            makeList com ctx r headAndTail
+            match headAndTail with
+            | None -> libCall com ctx r "List" "empty" [||]
+            | Some(TransformExpr com ctx head, TransformExpr com ctx tail) ->
+                libCall com ctx r "List" "cons" [|head; tail|]
         | Fable.NewOption (value, t) ->
             match value with
             | Some (TransformExpr com ctx e) ->
@@ -1102,8 +1101,10 @@ module Util =
         match getKind with
         | Fable.ByKey(Fable.ExprKey(TransformExpr com ctx prop)) -> getExpr range expr prop
         | Fable.ByKey(Fable.FieldKey field) -> get range expr field.Name
-        | Fable.ListHead -> get range expr "head"
-        | Fable.ListTail -> get range expr "tail"
+        // | Fable.ListHead -> get range expr "Head"
+        // | Fable.ListTail -> get range expr "Tail"
+        | Fable.ListHead -> libCall com ctx range "List" "head" [|expr|]
+        | Fable.ListTail -> libCall com ctx range "List" "tail" [|expr|]
         | Fable.TupleIndex index -> getExpr range expr (ofInt index)
         | Fable.OptionValue ->
             if mustWrapOption typ || com.Options.Typescript
@@ -1159,9 +1160,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)) "IsEmpty"
+            let expr = libCall com ctx range "List" "isEmpty" [|com.TransformAsExpr(ctx, expr)|]
+            if nonEmpty then upcast UnaryExpression(UnaryNot, expr, ?loc=range) else expr
         | Fable.UnionCaseTest tag ->
             let expected = ofInt tag
             let actual = com.TransformAsExpr(ctx, expr) |> getUnionExprTag None

src/Fable.Transforms/Replacements.fs

@@ -841,7 +841,7 @@ let makeMap (com: ICompiler) ctx r t methName args genArg =
     Helper.LibCall(com, "Map", Naming.lowerFirst methName, t, args, ?loc=r)
 
 let makeDictionaryWithComparer com r t sourceSeq comparer =
-    Helper.LibCall(com, "Map", "createMutable", t, [sourceSeq; comparer], ?loc=r)
+    Helper.LibCall(com, "MutableMap", "Dictionary", t, [sourceSeq; comparer], isJsConstructor=true, ?loc=r)
 
 let makeDictionary (com: ICompiler) ctx r t sourceSeq =
     match t with
@@ -852,7 +852,7 @@ let makeDictionary (com: ICompiler) ctx r t sourceSeq =
     | _ -> Helper.GlobalCall("Map", t, [sourceSeq], isJsConstructor=true, ?loc=r)
 
 let makeHashSetWithComparer com r t sourceSeq comparer =
-    Helper.LibCall(com, "Set", "createMutable", t, [sourceSeq; comparer], ?loc=r)
+    Helper.LibCall(com, "MutableSet", "HashSet", t, [sourceSeq; comparer], isJsConstructor=true, ?loc=r)
 
 let makeHashSet (com: ICompiler) ctx r t sourceSeq =
     match t with
@@ -1614,17 +1614,12 @@ let seqs (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Exp
 
     match i.CompiledName, args with
     | "Cast", [arg] -> Some arg // Erase
-    | ("Cache"|"ToArray"), [arg] -> toArray com t arg |> Some
+    | ("Cache" | "ToArray"), [arg] -> toArray com t arg |> Some
     | "OfList", [arg] -> toSeq t arg |> Some
     | "ToList", _ -> Helper.LibCall(com, "List", "ofSeq", t, args, i.SignatureArgTypes, ?loc=r) |> Some
-    | "ChunkBySize" | "Permute" as meth, [arg1; arg2] ->
+    | ("ChunkBySize" | "Permute" | "SplitInto") as meth, [arg1; arg2] ->
         let arg2 = toArray com (Array Any) arg2
-        let args =
-            match meth, t with
-            | "Permute", DeclaredType(_seq, [genArg]) ->
-                [arg1; arg2] @ [arrayCons com genArg]
-            | _ -> [arg1; arg2]
-        let result = Helper.LibCall(com, "Array", Naming.lowerFirst meth, Any, args)
+        let result = Helper.LibCall(com, "Array", Naming.lowerFirst meth, Any, [arg1; arg2])
         Helper.LibCall(com, "Seq", "ofArray", t, [result]) |> Some
     // For Using we need to cast the argument to IDisposable
     | "EnumerateUsing", [arg; f] ->
@@ -1696,6 +1691,8 @@ let resizeArrays (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (this
         Helper.LibCall(com, "Seq", "filter", t, [arg; ar], ?loc=r) |> toArray com t |> Some
     | "AddRange", Some ar, [arg] ->
         Helper.LibCall(com, "Array", "addRangeInPlace", t, [arg; ar], ?loc=r) |> Some
+    | "GetRange", Some ar, [idx; cnt] ->
+        Helper.LibCall(com, "Array", "getSubArray", t, [ar; idx; cnt], ?loc=r) |> Some
     | "Contains", Some (MaybeCasted(ar)), [arg] ->
         match ar.Type with
         | Array _ ->
@@ -1772,6 +1769,7 @@ let arrayModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Ex
     | "ToSeq", [arg] -> Some arg
     | "OfSeq", [arg] -> toArray com t arg |> Some
     | "OfList", [arg] -> listToArray com r t arg |> Some
+    | "ToList", _ -> Helper.LibCall(com, "List", "ofArray", t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | ("Length" | "Count"), [arg] -> get r t arg "length" |> Some
     | "Item", [idx; ar] -> getExpr r t ar idx |> Some
     | "Get", [ar; idx] -> getExpr r t ar idx |> Some
@@ -1803,29 +1801,26 @@ let arrayModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Ex
         Helper.LibCall(com, "Array", meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
 
 let lists (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
+    let meth = Naming.removeGetSetPrefix i.CompiledName |> Naming.lowerFirst
     match i.CompiledName, thisArg, args with
-    // Use methods for Head and Tail (instead of Get(ListHead) for example) to check for empty lists
-    | ReplaceName
-      [ "get_Head",   "head"
-        "get_Tail",   "tail"
-        "get_Item",   "item"
-        "get_Length", "length"
-        "GetSlice",   "slice" ] methName, Some x, _ ->
-            let args = match args with [ExprType Unit] -> [x] | args -> args @ [x]
-            Helper.LibCall(com, "List", methName, t, args, i.SignatureArgTypes, ?loc=r) |> Some
-    | "get_IsEmpty", Some x, _ -> Test(x, ListTest false, r) |> Some
-    | "get_Empty", None, _ -> NewList(None, (genArg com ctx r 0 i.GenericArgs)) |> makeValue r |> Some
-    | "Cons", None, [h;t] -> NewList(Some(h,t), (genArg com ctx r 0 i.GenericArgs)) |> makeValue r |> Some
+    | ("get_Head" | "get_Tail" | "get_IsEmpty" | "get_Length"), Some x, _ ->
+        Helper.LibCall(com, "List", meth, t, [x], i.SignatureArgTypes, ?loc=r) |> Some
+        // get r t x meth |> Some
+    | ("get_Item" | "GetSlice"), Some x, _ ->
+        Helper.LibCall(com, "List", meth, t, args @ [x], i.SignatureArgTypes, ?loc=r) |> Some
+    | ("get_Empty" | "Cons"), None, _ ->
+        Helper.LibCall(com, "List", meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | ("GetHashCode" | "Equals" | "CompareTo"), Some callee, _ ->
         Helper.InstanceCall(callee, i.CompiledName, t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | _ -> None
 
 let listModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Expr option) (args: Expr list) =
     match i.CompiledName, args with
-    | "IsEmpty", [x] -> Test(x, ListTest false, r) |> Some
-    | "Empty", _ -> NewList(None, (genArg com ctx r 0 i.GenericArgs)) |> makeValue r |> Some
-    | "Singleton", [x] ->
-        NewList(Some(x, Value(NewList(None, t), None)), (genArg com ctx r 0 i.GenericArgs)) |> makeValue r |> Some
+    // | ("Head" | "Tail" | "IsEmpty") as meth, [x] -> get r t x (Naming.lowerFirst meth) |> Some
+    // | "IsEmpty", [x] -> Test(x, ListTest false, r) |> Some
+    // | "Empty", _ -> NewList(None, (genArg com ctx r 0 i.GenericArgs)) |> makeValue r |> Some
+    // | "Singleton", [x] ->
+    //     NewList(Some(x, Value(NewList(None, t), None)), (genArg com ctx r 0 i.GenericArgs)) |> makeValue r |> Some
     // Use a cast to give it better chances of optimization (e.g. converting list
     // literals to arrays) after the beta reduction pass
     | "ToSeq", [x] -> toSeq t x |> Some
@@ -2612,12 +2607,6 @@ let enumerables (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr
     | Some callee, "GetEnumerator" -> getEnumerator com r t callee |> Some
     | _ -> None
 
-let enumerators (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
-    match i.CompiledName, thisArg with
-    | "get_Current", Some x -> get r t x "Current" |> Some
-    | meth, Some x -> Helper.InstanceCall(x, meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
-    | _ -> None
-
 let events (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
     match i.CompiledName, thisArg with
     | ".ctor", _ -> Helper.LibCall(com, "Event", "default", t, args, i.SignatureArgTypes, isJsConstructor=true, ?loc=r) |> Some
@@ -2904,11 +2893,6 @@ let private replacedModules =
     Types.ienumerable, enumerables
     "System.Collections.Generic.Dictionary`2.ValueCollection", enumerables
     "System.Collections.Generic.Dictionary`2.KeyCollection", enumerables
-    Types.ienumeratorGeneric, enumerators
-    "System.Collections.Generic.Dictionary`2.Enumerator", enumerators
-    "System.Collections.Generic.Dictionary`2.ValueCollection.Enumerator", enumerators
-    "System.Collections.Generic.Dictionary`2.KeyCollection.Enumerator", enumerators
-    "System.Collections.Generic.List`1.Enumerator", enumerators
     Types.resizeArray, resizeArrays
     "System.Collections.Generic.IList`1", resizeArrays
     "System.Collections.IList", resizeArrays
@@ -3044,7 +3028,7 @@ let tryBaseConstructor com ctx (ent: Entity) (argTypes: Lazy<Type list>) genArgs
             | [Number _; IEqualityComparer], [_; eqComp] ->
                 [makeArray Any []; makeComparerFromEqualityComparer eqComp]
             | _ -> failwith "Unexpected dictionary constructor"
-        let entityName = FSharp2Fable.Helpers.cleanNameAsJsIdentifier "MutableMap`2"
+        let entityName = FSharp2Fable.Helpers.cleanNameAsJsIdentifier "Dictionary"
         Some(makeImportLib com Any entityName "MutableMap", args)
     | Types.hashset ->
         let args =
@@ -3058,6 +3042,6 @@ let tryBaseConstructor com ctx (ent: Entity) (argTypes: Lazy<Type list>) genArgs
             | [IEqualityComparer], [eqComp] ->
                 [makeArray Any []; makeComparerFromEqualityComparer eqComp]
             | _ -> failwith "Unexpected hashset constructor"
-        let entityName = FSharp2Fable.Helpers.cleanNameAsJsIdentifier "MutableSet`1"
+        let entityName = FSharp2Fable.Helpers.cleanNameAsJsIdentifier "HashSet"
         Some(makeImportLib com Any entityName "MutableSet", args)
     | _ -> None

src/fable-library/Array.fs

@@ -101,8 +101,7 @@ module Helpers =
 
 open Helpers
 
-let private indexNotFound() =
-    failwith "An index satisfying the predicate was not found in the collection."
+let private indexNotFoundMsg = "An index satisfying the predicate was not found in the collection."
 
 // Pay attention when benchmarking to append and filter functions below
 // if implementing via native JS array .concat() and .filter() do not fall behind due to js-native transitions.
@@ -279,18 +278,18 @@ let except (itemsToExclude: seq<'T>) (array: 'T[]) ([<Inject>] eq: IEqualityComp
         array |> filterImpl cached.Add
 
 let groupBy (projection: 'T -> 'Key) (array: 'T[]) ([<Inject>] cons: IArrayCons<'T>) ([<Inject>] eq: IEqualityComparer<'Key>) =
-    let dict = Dictionary<'Key, 'T list>(eq)
+    let dict = Dictionary<'Key, ResizeArray<'T>>(eq)
     let keys: 'Key[] = [||]
     for v in array do
         let key = projection v
         match dict.TryGetValue(key) with
         | true, prev ->
-            dict.[key] <- v::prev
+            prev.Add(v)
         | false, _ ->
-            dict.Add(key, [v])
+            dict.Add(key, ResizeArray [|v|])
             pushImpl keys key |> ignore
     let result =
-        map (fun key -> key, (cons.FromSequence dict.[key] |> reverseImpl)) keys DynamicArrayCons
+        map (fun key -> key, cons.FromSequence dict.[key]) keys DynamicArrayCons
     result
 
 let inline private emptyImpl (cons: IArrayCons<'T>) = cons.Create(0)
@@ -445,15 +444,15 @@ let partition (f: 'T -> bool) (source: 'T[]) ([<Inject>] cons: IArrayCons<'T>) =
 let find (predicate: 'T -> bool) (array: 'T[]): 'T =
     match findImpl predicate array with
     | Some res -> res
-    | None -> indexNotFound()
+    | None -> failwith indexNotFoundMsg
 
 let tryFind (predicate: 'T -> bool) (array: 'T[]): 'T option =
     findImpl predicate array
 
 let findIndex (predicate: 'T -> bool) (array: 'T[]): int =
     match findIndexImpl predicate array with
     | index when index > -1 -> index
-    | _ -> indexNotFound()
+    | _ -> failwith indexNotFoundMsg
 
 let tryFindIndex (predicate: 'T -> bool) (array: 'T[]): int option =
     match findIndexImpl predicate array with
@@ -463,7 +462,7 @@ let tryFindIndex (predicate: 'T -> bool) (array: 'T[]): int option =
 let pick chooser (array: _[]) =
     let rec loop i =
         if i >= array.Length then
-            indexNotFound()
+            failwith indexNotFoundMsg
         else
             match chooser array.[i] with
             | None -> loop(i+1)
@@ -480,7 +479,7 @@ let tryPick chooser (array: _[]) =
 
 let findBack predicate (array: _[]) =
     let rec loop i =
-        if i < 0 then indexNotFound()
+        if i < 0 then failwith indexNotFoundMsg
         elif predicate array.[i] then array.[i]
         else loop (i - 1)
     loop (array.Length - 1)
@@ -501,7 +500,7 @@ let findLastIndex predicate (array: _[]) =
 
 let findIndexBack predicate (array: _[]) =
     let rec loop i =
-        if i < 0 then indexNotFound()
+        if i < 0 then failwith indexNotFoundMsg
         elif predicate array.[i] then i
         else loop (i - 1)
     loop (array.Length - 1)
@@ -847,13 +846,6 @@ let ofSeq (source: 'T seq) ([<Inject>] cons: IArrayCons<'T>) =
 let ofList (source: 'T list) ([<Inject>] cons: IArrayCons<'T>) =
     cons.FromSequence(source)
 
-let toList (source: 'T[]) =
-    let len = source.Length
-    let mutable target = []
-    for i = (len - 1) downto 0 do
-        target <- source.[i]::target
-    target
-
 // TODO: Pass array constructor here too?
 let windowed (windowSize: int) (source: 'T[]): 'T[][] =
     if windowSize <= 0 then