Added F# Seq type

Author: ncave

src/Fable.Transforms/Fable2Babel.fs

@@ -982,7 +982,7 @@ module Util =
 
     let enumerator2iterator com ctx =
         let enumerator = Expression.callExpression(get None (Expression.identifier("this")) "GetEnumerator", [||])
-        BlockStatement([| Statement.returnStatement(libCall com ctx None "Seq" "toIterator" [|enumerator|])|])
+        BlockStatement([| Statement.returnStatement(libCall com ctx None "Util" "toIterator" [|enumerator|])|])
 
     let extractBaseExprFromBaseCall (com: IBabelCompiler) (ctx: Context) (baseType: Fable.DeclaredType option) baseCall =
         match baseCall, baseType with

src/Fable.Transforms/Replacements.fs

@@ -1372,12 +1372,12 @@ let operators (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr o
             | _ -> args
         let modul, meth, args =
             match genArg with
-            | Char -> "Seq", "rangeChar", args
-            | Builtin BclInt64 -> "Seq", "rangeLong", (addStep args) @ [makeBoolConst false]
-            | Builtin BclUInt64 -> "Seq", "rangeLong", (addStep args) @ [makeBoolConst true]
-            | Builtin BclDecimal -> "Seq", "rangeDecimal", addStep args
-            | Builtin BclBigInt -> "BigInt", "range", addStep args
-            | _ -> "Seq", "rangeNumber", addStep args
+            | Char -> "Range", "rangeChar", args
+            | Builtin BclInt64 -> "Range", "rangeInt64", addStep args
+            | Builtin BclUInt64 -> "Range", "rangeUInt64", addStep args
+            | Builtin BclDecimal -> "Range", "rangeDecimal", addStep args
+            | Builtin BclBigInt -> "Range", "rangeBigInt", addStep args
+            | _ -> "Range", "rangeDouble", addStep args
         Helper.LibCall(com, modul, meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
     // Pipes and composition
     | "op_PipeRight", [x; f]
@@ -1542,7 +1542,7 @@ let implementedStringFunctions =
         |]
 
 let getEnumerator com r t expr =
-    Helper.LibCall(com, "Seq", "getEnumerator", t, [toSeq Any expr], ?loc=r)
+    Helper.LibCall(com, "Util", "getEnumerator", t, [toSeq Any expr], ?loc=r)
 
 let strings (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
     match i.CompiledName, thisArg, args with
@@ -1660,7 +1660,7 @@ let stringModule (com: ICompiler) (ctx: Context) r t (i: CallInfo) (_: Expr opti
     | meth, args ->
         Helper.LibCall(com, "String", Naming.lowerFirst meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
 
-let seqs (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
+let seqModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
     let sort r returnType descending projection args genArg =
         let compareFn =
             let identExpr ident =
@@ -1749,16 +1749,16 @@ let resizeArrays (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (this
     | "Clear", Some ar, _ ->
         Helper.LibCall(com, "Util", "clear", t, [ar], ?loc=r) |> Some
     | "Find", Some ar, [arg] ->
-        let opt = Helper.LibCall(com, "Seq", "tryFind", t, [arg; ar; defaultof com ctx t], ?loc=r)
-        Helper.LibCall(com, "Option", "value", t, [opt], ?loc=r) |> Some
+        let opt = Helper.LibCall(com, "Array", "tryFind", t, [arg; ar], ?loc=r)
+        Helper.LibCall(com, "Option", "defaultArg", t, [opt; defaultof com ctx t], ?loc=r) |> Some
     | "Exists", Some ar, [arg] ->
         let left = Helper.InstanceCall(ar, "findIndex", Number Int32, [arg], ?loc=r)
         makeEqOp r left (makeIntConst -1) BinaryGreater |> Some
     | "FindLast", Some ar, [arg] ->
-        let opt = Helper.LibCall(com, "Seq", "tryFindBack", t, [arg; ar; defaultof com ctx t], ?loc=r)
-        Helper.LibCall(com, "Option", "value", t, [opt], ?loc=r) |> Some
+        let opt = Helper.LibCall(com, "Array", "tryFindBack", t, [arg; ar], ?loc=r)
+        Helper.LibCall(com, "Option", "defaultArg", t, [opt; defaultof com ctx t], ?loc=r) |> Some
     | "FindAll", Some ar, [arg] ->
-        Helper.LibCall(com, "Seq", "filter", t, [arg; ar], ?loc=r) |> toArray r t |> Some
+        Helper.LibCall(com, "Array", "filter", t, [arg; ar], ?loc=r) |> Some
     | "AddRange", Some ar, [arg] ->
         Helper.LibCall(com, "Array", "addRangeInPlace", t, [arg; ar], ?loc=r) |> Some
     | "GetRange", Some ar, [idx; cnt] ->
@@ -1860,16 +1860,13 @@ let arrayModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Ex
         newArray (makeIntConst 0) t |> Some
     | "IsEmpty", [ar] ->
         eq (get r (Number Int32) ar "length") (makeIntConst 0) |> Some
-    | "AllPairs", args ->
-        let allPairs = Helper.LibCall(com, "Seq", "allPairs", t, args, i.SignatureArgTypes, ?loc=r)
-        toArray r t allPairs |> Some
     | "TryExactlyOne", args ->
         tryCoreOp com r t "Array" "exactlyOne" args |> Some
-    | "SortInPlace", args ->
-        let _, thisArg = List.splitLast args
-        let argTypes = List.take (List.length args) i.SignatureArgTypes
-        let compareFn = (genArg com ctx r 0 i.GenericArgs) |> makeComparerFunction com ctx
-        Helper.InstanceCall(thisArg, "sort", t, [compareFn], argTypes, ?loc=r) |> Some
+    // | "SortInPlace", args ->
+    //     let _, thisArg = List.splitLast args
+    //     let argTypes = List.take (List.length args) i.SignatureArgTypes
+    //     let compareFn = (genArg com ctx r 0 i.GenericArgs) |> makeComparerFunction com ctx
+    //     Helper.InstanceCall(thisArg, "sort", t, [compareFn], argTypes, ?loc=r) |> Some
     | "CopyTo", args ->
         copyToArray com r t i args
     | Patterns.DicContains nativeArrayFunctions meth, _ ->
@@ -1908,9 +1905,6 @@ let listModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Exp
     // 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
-    | "AllPairs", args ->
-        let allPairs = Helper.LibCall(com, "Seq", "allPairs", t, args, i.SignatureArgTypes, ?loc=r)
-        toList com t allPairs |> Some
     | "TryExactlyOne", args ->
         tryCoreOp com r t "List" "exactlyOne" args |> Some
     | meth, _ ->
@@ -1990,19 +1984,20 @@ let optionModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: E
         Helper.LibCall(com, "Option", Naming.lowerFirst meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | "ToArray", [arg] ->
         toArray r t arg |> Some
+    | "ToList", [arg] ->
+        let args = args |> List.replaceLast (toArray None t)
+        Helper.LibCall(com, "List", "ofArray", t, args, ?loc=r) |> Some
     | "FoldBack", [folder; opt; state] ->
         Helper.LibCall(com, "Seq", "foldBack", t, [folder; toArray None t opt; state], i.SignatureArgTypes, ?loc=r) |> Some
     | ("DefaultValue" | "OrElse"), _ ->
         Helper.LibCall(com, "Option", "defaultArg", t, List.rev args, ?loc=r) |> Some
     | ("DefaultWith" | "OrElseWith"), _ ->
         Helper.LibCall(com, "Option", "defaultArgWith", t, List.rev args, List.rev i.SignatureArgTypes, ?loc=r) |> Some
-    | ("Count" | "Contains" | "Exists" | "Fold" | "ForAll" | "Iterate" | "ToList" as meth), _ ->
+    | ("Count" | "Contains" | "Exists" | "Fold" | "ForAll" | "Iterate" as meth), _ ->
+        let meth = Naming.lowerFirst meth
         let args = args |> List.replaceLast (toArray None t)
-        let moduleName, meth =
-            if meth = "ToList"
-            then "List", "ofArray"
-            else "Seq", Naming.lowerFirst meth
-        Helper.LibCall(com, moduleName, meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
+        let args = injectArg com ctx r "Seq" meth i.GenericArgs args
+        Helper.LibCall(com, "Seq", meth, t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | _ -> None
 
 let parseBool (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
@@ -2267,18 +2262,19 @@ let intrinsicFunctions (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisAr
     // Type: RangeChar : char -> char -> seq<char>
     // Usage: RangeChar start stop
     | "RangeChar", None, _ ->
-        Helper.LibCall(com, "Seq", "rangeChar", t, args, i.SignatureArgTypes, ?loc=r) |> Some
+        Helper.LibCall(com, "Range", "rangeChar", t, args, i.SignatureArgTypes, ?loc=r) |> Some
     // reference: https://msdn.microsoft.com/visualfsharpdocs/conceptual/operatorintrinsics.rangedouble-function-%5bfsharp%5d
     // Type: RangeDouble: float -> float -> float -> seq<float>
     // Usage: RangeDouble start step stop
     | ("RangeSByte" | "RangeByte"
     | "RangeInt16"  | "RangeUInt16"
     | "RangeInt32"  | "RangeUInt32"
     | "RangeSingle" | "RangeDouble"), None, args ->
-        Helper.LibCall(com, "Seq", "rangeNumber", t, args, i.SignatureArgTypes, ?loc=r) |> Some
-    | ("RangeInt64" | "RangeUInt64"), None, args ->
-        let isUnsigned = makeBoolConst (i.CompiledName = "RangeUInt64")
-        Helper.LibCall(com, "Seq", "rangeLong", t, args @ [isUnsigned] , i.SignatureArgTypes, ?loc=r) |> Some
+        Helper.LibCall(com, "Range", "rangeDouble", t, args, i.SignatureArgTypes, ?loc=r) |> Some
+    | "RangeInt64", None, args ->
+        Helper.LibCall(com, "Range", "rangeInt64", t, args, i.SignatureArgTypes, ?loc=r) |> Some
+    | "RangeUInt64", None, args ->
+        Helper.LibCall(com, "Range", "rangeUInt64", t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | _ -> None
 
 let runtimeHelpers (com: ICompiler) (ctx: Context) r t (i: CallInfo) thisArg args =
@@ -3062,8 +3058,8 @@ let private replacedModules =
     "Microsoft.FSharp.Collections.ListModule", listModule
     "Microsoft.FSharp.Collections.HashIdentity", fsharpModule
     "Microsoft.FSharp.Collections.ComparisonIdentity", fsharpModule
-    "Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers", seqs
-    "Microsoft.FSharp.Collections.SeqModule", seqs
+    "Microsoft.FSharp.Core.CompilerServices.RuntimeHelpers", seqModule
+    "Microsoft.FSharp.Collections.SeqModule", seqModule
     "System.Collections.Generic.KeyValuePair`2", keyValuePairs
     "System.Collections.Generic.Comparer`1", bclType
     "System.Collections.Generic.EqualityComparer`1", bclType

src/Fable.Transforms/ReplacementsInject.fs

@@ -78,6 +78,22 @@ let fableReplacementsModules =
       "groupBy", (Types.equalityComparer, 1)
       "countBy", (Types.equalityComparer, 1)
     ]
+    "Seq", Map [
+      "contains", (Types.equalityComparer, 0)
+      "except", (Types.equalityComparer, 0)
+      "sort", (Types.comparer, 0)
+      "sortBy", (Types.comparer, 1)
+      "sortDescending", (Types.comparer, 0)
+      "sortByDescending", (Types.comparer, 1)
+      "sum", ("Fable.Core.IGenericAdder`1", 0)
+      "sumBy", ("Fable.Core.IGenericAdder`1", 1)
+      "maxBy", (Types.comparer, 1)
+      "max", (Types.comparer, 0)
+      "minBy", (Types.comparer, 1)
+      "min", (Types.comparer, 0)
+      "average", ("Fable.Core.IGenericAverager`1", 0)
+      "averageBy", ("Fable.Core.IGenericAverager`1", 1)
+    ]
     "Set", Map [
       "FSharpSet__Map", (Types.comparer, 1)
       "singleton", (Types.comparer, 0)

src/fable-library/Array.fs

@@ -676,6 +676,15 @@ let sortByDescending (projection: 'a->'b) (xs: 'a[]) ([<Inject>] comparer: IComp
 let sortWith (comparer: 'T -> 'T -> int) (xs: 'T[]): 'T[] =
     sortInPlaceWith comparer (copyImpl xs)
 
+let allPairs (xs: 'T1[]) (ys: 'T2[]): ('T1 * 'T2)[] =
+    let len1 = xs.Length
+    let len2 = ys.Length
+    let res = allocateArray (len1 * len2)
+    for i = 0 to xs.Length-1 do
+        for j = 0 to ys.Length-1 do
+            res.[i * len2 + j] <- (xs.[i], ys.[j])
+    res
+
 let unfold<'T, 'State> (generator: 'State -> ('T*'State) option) (state: 'State): 'T[] =
     let res: 'T[] = [||]
     let rec loop state =

src/fable-library/Async.ts

@@ -7,7 +7,6 @@ import { protectedCont } from "./AsyncBuilder.js";
 import { protectedBind } from "./AsyncBuilder.js";
 import { protectedReturn } from "./AsyncBuilder.js";
 import { FSharpChoice$2, Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
-import { map } from "./Seq.js";
 
 // Implemented just for type references
 export class Async<_T> { }
@@ -102,7 +101,7 @@ export function ignore<T>(computation: IAsync<T>) {
 }
 
 export function parallel<T>(computations: Iterable<IAsync<T>>) {
-  return awaitPromise(Promise.all(map((w) => startAsPromise(w), computations)));
+  return awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w))));
 }
 
 export function sleep(millisecondsDueTime: number) {

src/fable-library/BigInt.fs

@@ -170,19 +170,3 @@ let fromByteArray (bytes:byte array) =
                         ||| (uint32 b3 <<< 24)
                     loop (value :: accumUInt32) (currIndex + bytesToProcess) (bytesRemaining - bytesToProcess) lowBitFound
         loop [] 0 bytes.Length false
-
-let makeRangeStepFunction (step: bigint) (last: bigint) =
-    let stepComparedWithZero = compare step zero
-    if stepComparedWithZero = 0 then
-        failwith "The step of a range cannot be zero"
-    let stepGreaterThanZero = stepComparedWithZero > 0
-    fun (x: bigint) ->
-        let comparedWithLast = compare x last
-        if (stepGreaterThanZero && comparedWithLast <= 0)
-            || (not stepGreaterThanZero && comparedWithLast >= 0) then
-            Some (x, x + step)
-        else None
-
-let range (first: bigint) (step: bigint) (last: bigint) =
-    let stepFn = makeRangeStepFunction step last
-    Seq.delay(fun () -> Seq.unfold stepFn first)

src/fable-library/Decimal.ts

@@ -194,19 +194,19 @@ export function getBits(d: Decimal) {
   return [low, mid, high, signExp];
 }
 
-export function makeRangeStepFunction(step: Decimal, last: Decimal) {
-  const stepComparedWithZero = step.cmp(get_Zero);
-  if (stepComparedWithZero === 0) {
-    throw new Error("The step of a range cannot be zero");
-  }
-  const stepGreaterThanZero = stepComparedWithZero > 0;
-  return (x: Decimal) => {
-    const comparedWithLast = x.cmp(last);
-    if ((stepGreaterThanZero && comparedWithLast <= 0)
-      || (!stepGreaterThanZero && comparedWithLast >= 0)) {
-      return [x, op_Addition(x, step)];
-    } else {
-      return undefined;
-    }
-  };
-}
+// export function makeRangeStepFunction(step: Decimal, last: Decimal) {
+//   const stepComparedWithZero = step.cmp(get_Zero);
+//   if (stepComparedWithZero === 0) {
+//     throw new Error("The step of a range cannot be zero");
+//   }
+//   const stepGreaterThanZero = stepComparedWithZero > 0;
+//   return (x: Decimal) => {
+//     const comparedWithLast = x.cmp(last);
+//     if ((stepGreaterThanZero && comparedWithLast <= 0)
+//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {
+//       return [x, op_Addition(x, step)];
+//     } else {
+//       return undefined;
+//     }
+//   };
+// }

src/fable-library/Event.ts

@@ -1,7 +1,6 @@
 import { IObservable, IObserver, Observer, protect } from "./Observable.js";
 import { Option, some, value } from "./Option.js";
 import { FSharpChoice$2, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
-import { iterate as seqIterate } from "./Seq.js";
 import { IDisposable } from "./Util.js";
 
 export type Delegate<T> = (x: T) => void;
@@ -38,7 +37,7 @@ export class Event<T> implements IEvent<T> {
   }
 
   public Trigger(value: T) {
-    seqIterate((f) => f(value), this.delegates);
+    this.delegates.forEach((f) => f(value));
   }
 
   // IDelegateEvent<T> methods

src/fable-library/Fable.Library.fsproj

@@ -24,6 +24,8 @@
     <Compile Include="Choice.fs" />
     <Compile Include="Array.fs" />
     <Compile Include="List.fs" />
+    <Compile Include="Seq.fs" />
+    <Compile Include="Range.fs" />
     <Compile Include="Set.fs" />
     <Compile Include="Map.fs" />
   </ItemGroup>