Updated System.Collections

Author: ncave

fcs/fcs-fable/System.Collections.fs

@@ -4,29 +4,6 @@
 
 namespace System.Collections
 
-module Generic =
-
-    type Queue<'T>() =
-        let xs = ResizeArray<'T>()
-
-        member _.Clear () = xs.Clear()
-
-        member _.Enqueue (item: 'T) =
-            xs.Add(item)
-
-        member _.Dequeue () =
-            let item = xs.Item(0)
-            xs.RemoveAt(0)
-            item
-
-        interface System.Collections.IEnumerable with
-            member _.GetEnumerator() =
-                (xs.GetEnumerator() :> System.Collections.IEnumerator)
-
-        interface System.Collections.Generic.IEnumerable<'T> with
-            member _.GetEnumerator() =
-                xs.GetEnumerator()
-
 module Immutable =
     open System.Collections.Generic
 
@@ -35,7 +12,7 @@ module Immutable =
         static member CreateBuilder() = ResizeArray<'T>()
 
     [<Sealed>]
-    type ImmutableHashSet<'T>(values: 'T seq) =
+    type ImmutableHashSet<'T when 'T: equality>(values: 'T seq) =
         let xs = HashSet<'T>(values)
 
         static member Create<'T>(values) = ImmutableHashSet<'T>(values)
@@ -48,61 +25,63 @@ module Immutable =
 
         member _.Union (values: seq<'T>) =
             let copy = HashSet<'T>(xs)
-            copy.UnionWith(values)
+            // copy.UnionWith(values)
+            for value in values do
+                copy.Add(value) |> ignore
             ImmutableHashSet<'T>(copy)
 
         member _.Overlaps (values: seq<'T>) =
             // xs.Overlaps(values)
             values |> Seq.exists (fun x -> xs.Contains(x))
 
-        interface System.Collections.IEnumerable with
-            member _.GetEnumerator() =
-                (xs.GetEnumerator() :> System.Collections.IEnumerator)
-
         interface IEnumerable<'T> with
             member _.GetEnumerator() =
                 xs.GetEnumerator()
 
+        interface System.Collections.IEnumerable with
+            member _.GetEnumerator() =
+                (xs.GetEnumerator() :> System.Collections.IEnumerator)
+
     [<Sealed>]
-    type ImmutableDictionary<'Key, 'Value when 'Key: equality>(xs: Dictionary<'Key, 'Value>) =
-        static member Create(comparer: IEqualityComparer<'Key>) =
-            ImmutableDictionary<'Key, 'Value>(Dictionary(comparer))
+    type ImmutableDictionary<'K, 'V when 'K: equality>(xs: Dictionary<'K, 'V>) =
+        static member Create(comparer: IEqualityComparer<'K>) =
+            ImmutableDictionary<'K, 'V>(Dictionary(comparer))
 
-        static member CreateRange(items: IEnumerable<KeyValuePair<'Key, 'Value>>) =
-            let xs = Dictionary<'Key, 'Value>()
+        static member CreateRange(items: IEnumerable<KeyValuePair<'K, 'V>>) =
+            let xs = Dictionary<'K, 'V>()
             for pair in items do
                 xs.Add(pair.Key, pair.Value)
-            ImmutableDictionary<'Key, 'Value>(xs)
+            ImmutableDictionary<'K, 'V>(xs)
 
         static member Empty =
-            ImmutableDictionary<'Key, 'Value>(Dictionary())
+            ImmutableDictionary<'K, 'V>(Dictionary())
 
         member _.IsEmpty = xs.Count = 0
-        member _.Item with get (key: 'Key): 'Value = xs[key]
-        member _.ContainsKey (key: 'Key) = xs.ContainsKey(key)
+        member _.Item with get (key: 'K): 'V = xs[key]
+        member _.ContainsKey (key: 'K) = xs.ContainsKey(key)
 
-        member _.Add (key: 'Key, value: 'Value) =
-            let copy = Dictionary<'Key, 'Value>(xs)
+        member _.Add (key: 'K, value: 'V) =
+            let copy = Dictionary<'K, 'V>(xs)
             copy.Add(key, value)
-            ImmutableDictionary<'Key, 'Value>(copy)
+            ImmutableDictionary<'K, 'V>(copy)
 
-        member _.SetItem (key: 'Key, value: 'Value) =
-            let copy = Dictionary<'Key, 'Value>(xs)
+        member _.SetItem (key: 'K, value: 'V) =
+            let copy = Dictionary<'K, 'V>(xs)
             copy[key] <- value
-            ImmutableDictionary<'Key, 'Value>(copy)
+            ImmutableDictionary<'K, 'V>(copy)
 
-        member _.TryGetValue (key: 'Key): bool * 'Value =
+        member _.TryGetValue (key: 'K): bool * 'V =
             match xs.TryGetValue(key) with
             | true, v -> (true, v)
             | false, v -> (false, v)
 
-        interface System.Collections.IEnumerable with
+        interface IEnumerable<KeyValuePair<'K, 'V>> with
             member _.GetEnumerator() =
-                (xs.GetEnumerator() :> System.Collections.IEnumerator)
+                xs.GetEnumerator()
 
-        interface IEnumerable<KeyValuePair<'Key, 'Value>> with
+        interface System.Collections.IEnumerable with
             member _.GetEnumerator() =
-                xs.GetEnumerator()
+                (xs.GetEnumerator() :> System.Collections.IEnumerator)
 
 module Concurrent =
     open System.Collections.Generic
@@ -116,92 +95,95 @@ module Concurrent =
         member _.Clear () = xs.Clear()
         member _.ToArray () = xs.ToArray()
 
-        interface System.Collections.IEnumerable with
-            member _.GetEnumerator() =
-                (xs.GetEnumerator() :> System.Collections.IEnumerator)
-
         interface IEnumerable<'T> with
             member _.GetEnumerator() =
                 xs.GetEnumerator()
 
+        interface System.Collections.IEnumerable with
+            member _.GetEnumerator() =
+                (xs.GetEnumerator() :> System.Collections.IEnumerator)
+
     // not thread safe, just a Dictionary // TODO: threaded implementation
     [<AllowNullLiteral>]
-    type ConcurrentDictionary<'Key, 'Value>(comparer: IEqualityComparer<'Key>) =
+    type ConcurrentDictionary<'K, 'V>(comparer: IEqualityComparer<'K>) =
         let xs = Dictionary(comparer)
 
         new () =
-            ConcurrentDictionary<'Key, 'Value>(EqualityComparer.Default)
+            ConcurrentDictionary<'K, 'V>(EqualityComparer.Default)
         new (_concurrencyLevel: int, _capacity: int) =
-            ConcurrentDictionary<'Key, 'Value>()
-        new (_concurrencyLevel: int, comparer: IEqualityComparer<'Key>) =
-            ConcurrentDictionary<'Key, 'Value>(comparer)
-        new (_concurrencyLevel: int, _capacity: int, comparer: IEqualityComparer<'Key>) =
-            ConcurrentDictionary<'Key, 'Value>(comparer)
+            ConcurrentDictionary<'K, 'V>()
+        new (_concurrencyLevel: int, comparer: IEqualityComparer<'K>) =
+            ConcurrentDictionary<'K, 'V>(comparer)
+        new (_concurrencyLevel: int, _capacity: int, comparer: IEqualityComparer<'K>) =
+            ConcurrentDictionary<'K, 'V>(comparer)
 
+        member _.Comparer = comparer
         member _.Keys = xs.Keys
         member _.Values = xs.Values
 
         member _.Item
-            with get (key: 'Key): 'Value = xs[key]
-            and set (key: 'Key) (value: 'Value) = xs[key] <- value
+            with get (key: 'K): 'V = xs[key]
+            and set (key: 'K) (value: 'V) = xs[key] <- value
 
         member _.Clear () = xs.Clear()
-        member _.ContainsKey (key: 'Key) = xs.ContainsKey(key)
+        member _.ContainsKey (key: 'K) = xs.ContainsKey(key)
 
-        member _.TryGetValue (key: 'Key): bool * 'Value =
+        member _.TryGetValue (key: 'K): bool * 'V =
             match xs.TryGetValue(key) with
             | true, v -> (true, v)
             | false, v -> (false, v)
 
-        member _.TryAdd (key: 'Key, value: 'Value): bool =
+        member _.TryAdd (key: 'K, value: 'V): bool =
             if xs.ContainsKey(key)
             then false
             else xs.Add(key, value); true
 
-        member _.TryRemove (key: 'Key): bool * 'Value =
+        member _.TryRemove (key: 'K): bool * 'V =
             match xs.TryGetValue(key) with
             | true, v -> (xs.Remove(key), v)
             | _ as res -> res
 
-        member _.GetOrAdd (key: 'Key, value: 'Value): 'Value =
+        member _.GetOrAdd (key: 'K, value: 'V): 'V =
             match xs.TryGetValue(key) with
             | true, v -> v
             | _ -> let v = value in xs.Add(key, v); v
 
-        member _.GetOrAdd (key: 'Key, valueFactory: System.Func<'Key, 'Value>): 'Value =
+        member _.GetOrAdd (key: 'K, valueFactory: System.Func<'K, 'V>): 'V =
             match xs.TryGetValue(key) with
             | true, v -> v
             | _ -> let v = valueFactory.Invoke(key) in xs.Add(key, v); v
 
-        // member _.GetOrAdd<'Arg> (key: 'Key, valueFactory: 'Key * 'Arg -> 'Value, arg: 'Arg): 'Value =
+        // member _.GetOrAdd<'Arg> (key: 'K, valueFactory: 'K * 'Arg -> 'V, arg: 'Arg): 'V =
         //     match xs.TryGetValue(key) with
         //     | true, v -> v
         //     | _ -> let v = valueFactory(key, arg) in xs.Add(key, v); v
 
-        member _.TryUpdate (key: 'Key, value: 'Value, comparisonValue: 'Value): bool =
-            match xs.TryGetValue(key) with
-            | true, v when Unchecked.equals v comparisonValue -> xs[key] <- value; true
-            | _ -> false
+        member _.TryUpdate (key: 'K, value: 'V, comparisonValue: 'V): bool =
+            // match xs.TryGetValue(key) with
+            // | true, v when Unchecked.equals v comparisonValue -> xs[key] <- value; true
+            // | _ -> false
+            xs[key] <- value
+            true
 
-        member _.AddOrUpdate (key: 'Key, value: 'Value, updateFactory: System.Func<'Key, 'Value, 'Value>): 'Value =
+        member _.AddOrUpdate (key: 'K, value: 'V, updateFactory: System.Func<'K, 'V, 'V>): 'V =
             match xs.TryGetValue(key) with
             | true, v -> let v = updateFactory.Invoke(key, v) in xs[key] <- v; v
             | _ -> let v = value in xs.Add(key, v); v
 
-        // member _.AddOrUpdate (key: 'Key, valueFactory: 'Key -> 'Value, updateFactory: 'Key * 'Value -> 'Value): 'Value =
+        // member _.AddOrUpdate (key: 'K, valueFactory: 'K -> 'V, updateFactory: 'K * 'V -> 'V): 'V =
         //     match xs.TryGetValue(key) with
         //     | true, v -> let v = updateFactory(key, v) in xs[key] <- v; v
         //     | _ -> let v = valueFactory(key) in xs.Add(key, v); v
 
-        // member _.AddOrUpdate (key: 'Key, valueFactory: 'Key * 'Arg -> 'Value, updateFactory: 'Key * 'Arg * 'Value -> 'Value, arg: 'Arg): 'Value =
+        // member _.AddOrUpdate (key: 'K, valueFactory: 'K * 'Arg -> 'V, updateFactory: 'K * 'Arg * 'V -> 'V, arg: 'Arg): 'V =
         //     match xs.TryGetValue(key) with
         //     | true, v -> let v = updateFactory(key, arg, v) in xs[key] <- v; v
         //     | _ -> let v = valueFactory(key, arg) in xs.Add(key, v); v
 
-        interface System.Collections.IEnumerable with
+        interface IEnumerable<KeyValuePair<'K, 'V>> with
             member _.GetEnumerator() =
-                (xs.GetEnumerator() :> System.Collections.IEnumerator)
+                xs.GetEnumerator()
 
-        interface IEnumerable<KeyValuePair<'Key, 'Value>> with
+        interface System.Collections.IEnumerable with
             member _.GetEnumerator() =
-                xs.GetEnumerator()
+                (xs.GetEnumerator() :> System.Collections.IEnumerator)

src/Compiler/Symbols/Exprs.fs

@@ -1255,13 +1255,8 @@ module FSharpExprConvert =
             | Const.UInt32  i ->  E.Const(box i, tyR)
             | Const.Int64   i ->  E.Const(box i, tyR)
             | Const.UInt64  i ->  E.Const(box i, tyR)
-#if FABLE_COMPILER
-            | Const.IntPtr  i ->  E.Const(box i, tyR)
-            | Const.UIntPtr i ->  E.Const(box i, tyR)
-#else
             | Const.IntPtr  i ->  E.Const(box (nativeint i), tyR)
             | Const.UIntPtr i ->  E.Const(box (unativeint i), tyR)
-#endif
             | Const.Decimal i ->  E.Const(box i, tyR)
             | Const.Double  i ->  E.Const(box i, tyR)
             | Const.Single  i ->  E.Const(box i, tyR)