diff --git a/src/Fable.Transforms/Rust/AST/Rust.AST.Helpers.fs b/src/Fable.Transforms/Rust/AST/Rust.AST.Helpers.fs
index 9fbe85af1..bd8d6137c 100644
--- a/src/Fable.Transforms/Rust/AST/Rust.AST.Helpers.fs
+++ b/src/Fable.Transforms/Rust/AST/Rust.AST.Helpers.fs
@@ -383,18 +383,20 @@ module Paths =
             tokens = None
         }
 
-    let mkGenericPath (names: Symbol seq) (genArgs: GenericArgs option) : Path =
+    let mkGenericOffsetPath (names: Symbol seq) (genArgs: GenericArgs option) (offset: int) : Path =
         let len = Seq.length names
         let idents = mkPathIdents names
 
         let args i =
-            if i < len - 1 then
-                None
-            else
+            if i = len - 1 - offset then
                 genArgs
+            else
+                None
 
         idents |> Seq.mapi (fun i ident -> mkPathSegment ident (args i)) |> mkPath
 
+    let mkGenericPath (names: Symbol seq) (genArgs: GenericArgs option) : Path = mkGenericOffsetPath names genArgs 0
+
 [<AutoOpen>]
 module Patterns =
 
diff --git a/src/Fable.Transforms/Rust/Fable2Rust.fs b/src/Fable.Transforms/Rust/Fable2Rust.fs
index bad7b9185..4cc629912 100644
--- a/src/Fable.Transforms/Rust/Fable2Rust.fs
+++ b/src/Fable.Transforms/Rust/Fable2Rust.fs
@@ -304,6 +304,12 @@ module TypeInfo =
         let parts = splitNameParts fullName
         mkGenericPath parts genArgsOpt
 
+    let makeStaticCallPathExpr importName membName genArgsOpt =
+        let fullName = importName + "::" + membName
+        let parts = splitNameParts fullName
+        let offset = 1 // genArgs position offset is one before last
+        mkGenericOffsetPath parts genArgsOpt offset |> mkPathExpr
+
     let makeFullNamePathExpr fullName genArgsOpt =
         makeFullNamePath fullName genArgsOpt |> mkPathExpr
 
@@ -665,12 +671,12 @@ module TypeInfo =
                     // for constructors or static members, import just the type
                     let selector, membName = Fable.Naming.splitLastBy "." info.Selector
                     let importName = com.GetImportName(ctx, selector, info.Path, r)
-                    makeFullNamePathExpr (importName + "::" + membName) genArgsOpt
+                    makeStaticCallPathExpr importName membName genArgsOpt
             | Fable.LibraryImport mi when not (mi.IsInstanceMember) && not (mi.IsModuleMember) ->
                 // for static (non-module and non-instance) members, import just the type
                 let selector, membName = Fable.Naming.splitLastBy "::" info.Selector
                 let importName = com.GetImportName(ctx, selector, info.Path, r)
-                makeFullNamePathExpr (importName + "::" + membName) genArgsOpt
+                makeStaticCallPathExpr importName membName genArgsOpt
             | _ ->
                 // all other imports
                 let importName = com.GetImportName(ctx, info.Selector, info.Path, r)
@@ -2338,9 +2344,9 @@ module Util =
                     mkCallExpr callee [] |> mutableGet
                 else
                     mkCallExpr callee args
-            | None, Fable.LibraryImport memberInfo ->
+            | None, Fable.LibraryImport mi ->
                 let genArgsOpt =
-                    if needGenArgs && memberInfo.IsModuleMember then
+                    if needGenArgs && (mi.IsModuleMember || not mi.IsInstanceMember) then
                         match typ with
                         | Fable.Tuple _ -> transformGenArgs com ctx [ typ ]
                         | _ -> transformGenArgs com ctx typ.Generics
@@ -3678,7 +3684,7 @@ module Util =
             | Fable.Constraint.CoercesTo(targetType) ->
                 match targetType with
                 | IFormattable -> [ makeGenBound ("core" :: "fmt" :: "Display" :: []) [] ]
-                | IEquatable _ -> [ makeRawBound "Eq"; makeGenBound ("core" :: "hash" :: "Hash" :: []) [] ]
+                | IEquatable _ -> [ makeGenBound ("core" :: "hash" :: "Hash" :: []) []; makeRawBound "PartialEq" ]
                 | Fable.DeclaredType(entRef, genArgs) ->
                     let ent = com.GetEntity(entRef)
 
@@ -3697,8 +3703,8 @@ module Util =
             | Fable.Constraint.HasComparison -> [ makeRawBound "PartialOrd" ]
             | Fable.Constraint.HasEquality ->
                 [
-                    makeRawBound "Eq" // "PartialEq"
                     makeGenBound ("core" :: "hash" :: "Hash" :: []) []
+                    makeRawBound "PartialEq" // "Eq"
                 ]
             | Fable.Constraint.IsUnmanaged -> []
             | Fable.Constraint.IsEnum -> []
diff --git a/src/fable-library-rust/src/HashMap.rs b/src/fable-library-rust/src/HashMap.rs
index c2dee0058..cbcb1a8eb 100644
--- a/src/fable-library-rust/src/HashMap.rs
+++ b/src/fable-library-rust/src/HashMap.rs
@@ -9,9 +9,10 @@ pub mod HashMap_ {
     #[cfg(not(feature = "no_std"))]
     use std::collections;
 
-    use crate::System::Collections::Generic::IEqualityComparer_1;
     use crate::NativeArray_::{array_from, Array};
     use crate::Native_::{mkRefMut, seq_to_iter, HashKey, Lrc, LrcPtr, MutCell, Seq, Vec};
+    use crate::System::Collections::Generic::EqualityComparer_1;
+    use crate::System::Collections::Generic::IEqualityComparer_1;
 
     use core::fmt::{Debug, Display, Formatter, Result};
     use core::hash::{Hash, Hasher};
@@ -21,10 +22,13 @@ pub mod HashMap_ {
     #[derive(Clone)] //, Debug, Default, PartialEq, PartialOrd, Eq, Hash, Ord)]
     pub struct HashMap<K: Clone, V: Clone> {
         hash_map: Lrc<MutHashMap<K, V>>,
-        comparer: Option<LrcPtr<dyn IEqualityComparer_1<K>>>,
+        comparer: LrcPtr<dyn IEqualityComparer_1<K>>,
     }
 
-    impl<K: Clone, V: Clone> Default for HashMap<K, V> {
+    impl<K, V: Clone> Default for HashMap<K, V>
+    where
+        K: Clone + Hash + PartialEq + 'static,
+    {
         fn default() -> HashMap<K, V> {
             new_empty()
         }
@@ -49,13 +53,10 @@ pub mod HashMap_ {
         }
     }
 
-    fn from_iter<K, V: Clone, I: Iterator<Item = (K, V)>>(
+    fn from_iter<K: Clone + 'static, V: Clone, I: Iterator<Item = (K, V)>>(
         iter: I,
-        comparer: Option<LrcPtr<dyn IEqualityComparer_1<K>>>,
-    ) -> HashMap<K, V>
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+        comparer: LrcPtr<dyn IEqualityComparer_1<K>>,
+    ) -> HashMap<K, V> {
         let it = iter.map(|(k, v)| {
             let key = HashKey::new(k, comparer.clone());
             (key, v)
@@ -70,17 +71,23 @@ pub mod HashMap_ {
         map.iter().map(|(k, v)| (k.key.clone(), v.clone()))
     }
 
-    pub fn new_empty<K: Clone, V: Clone>() -> HashMap<K, V> {
+    pub fn new_empty<K, V: Clone>() -> HashMap<K, V>
+    where
+        K: Clone + Hash + PartialEq + 'static,
+    {
         HashMap {
             hash_map: mkRefMut(collections::HashMap::new()),
-            comparer: None,
+            comparer: EqualityComparer_1::<K>::get_Default(),
         }
     }
 
-    pub fn new_with_capacity<K: Clone, V: Clone>(capacity: i32) -> HashMap<K, V> {
+    pub fn new_with_capacity<K, V: Clone>(capacity: i32) -> HashMap<K, V>
+    where
+        K: Clone + Hash + PartialEq + 'static,
+    {
         HashMap {
             hash_map: mkRefMut(collections::HashMap::with_capacity(capacity as usize)),
-            comparer: None,
+            comparer: EqualityComparer_1::<K>::get_Default(),
         }
     }
 
@@ -89,7 +96,7 @@ pub mod HashMap_ {
     ) -> HashMap<K, V> {
         HashMap {
             hash_map: mkRefMut(collections::HashMap::new()),
-            comparer: Some(comparer),
+            comparer,
         }
     }
 
@@ -99,7 +106,7 @@ pub mod HashMap_ {
     ) -> HashMap<K, V> {
         HashMap {
             hash_map: mkRefMut(collections::HashMap::with_capacity(capacity as usize)),
-            comparer: Some(comparer),
+            comparer,
         }
     }
 
@@ -107,34 +114,25 @@ pub mod HashMap_ {
     where
         K: Clone + Hash + PartialEq + 'static,
     {
-        from_iter(seq_to_iter(&seq), None)
+        from_iter(seq_to_iter(&seq), EqualityComparer_1::<K>::get_Default())
     }
 
-    pub fn new_from_enumerable_comparer<K, V: Clone + 'static>(
+    pub fn new_from_enumerable_comparer<K: Clone + 'static, V: Clone + 'static>(
         seq: Seq<(K, V)>,
         comparer: LrcPtr<dyn IEqualityComparer_1<K>>,
-    ) -> HashMap<K, V>
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
-        from_iter(seq_to_iter(&seq), Some(comparer))
+    ) -> HashMap<K, V> {
+        from_iter(seq_to_iter(&seq), comparer)
     }
 
-    pub fn new_from_dictionary<K, V: Clone + 'static>(map: HashMap<K, V>) -> HashMap<K, V>
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
-        from_iter(to_iter(&map), None)
+    pub fn new_from_dictionary<K: Clone + 'static, V: Clone>(map: HashMap<K, V>) -> HashMap<K, V> {
+        from_iter(to_iter(&map), map.comparer.clone())
     }
 
-    pub fn new_from_dictionary_comparer<K, V: Clone + 'static>(
+    pub fn new_from_dictionary_comparer<K: Clone + 'static, V: Clone>(
         map: HashMap<K, V>,
         comparer: LrcPtr<dyn IEqualityComparer_1<K>>,
-    ) -> HashMap<K, V>
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
-        from_iter(to_iter(&map), Some(comparer))
+    ) -> HashMap<K, V> {
+        from_iter(to_iter(&map), comparer)
     }
 
     pub fn new_from_tuple_array<K, V: Clone>(a: Array<LrcPtr<(K, V)>>) -> HashMap<K, V>
@@ -142,7 +140,7 @@ pub mod HashMap_ {
         K: Clone + Hash + PartialEq + 'static,
     {
         let it = a.iter().map(|tup| tup.as_ref().clone());
-        from_iter(it, None)
+        from_iter(it, EqualityComparer_1::<K>::get_Default())
     }
 
     pub fn isReadOnly<K: Clone, V: Clone>(map: HashMap<K, V>) -> bool {
@@ -153,10 +151,7 @@ pub mod HashMap_ {
         map.len() as i32
     }
 
-    pub fn containsKey<K, V: Clone>(map: HashMap<K, V>, k: K) -> bool
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn containsKey<K: Clone + 'static, V: Clone>(map: HashMap<K, V>, k: K) -> bool {
         let key = HashKey::new(k, map.comparer.clone());
         map.contains_key(&key)
     }
@@ -165,10 +160,7 @@ pub mod HashMap_ {
         map.values().any(|x| x.eq(&v))
     }
 
-    pub fn tryAdd<K, V: Clone>(map: HashMap<K, V>, k: K, v: V) -> bool
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn tryAdd<K: Clone + 'static, V: Clone>(map: HashMap<K, V>, k: K, v: V) -> bool {
         let key = HashKey::new(k, map.comparer.clone());
         // map.get_mut().try_insert(key, v).is_ok() // nightly only
         if map.contains_key(&key) {
@@ -178,10 +170,7 @@ pub mod HashMap_ {
         }
     }
 
-    pub fn add<K, V: Clone>(map: HashMap<K, V>, k: K, v: V)
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn add<K: Clone + 'static, V: Clone>(map: HashMap<K, V>, k: K, v: V) {
         let key = HashKey::new(k, map.comparer.clone());
         match map.get_mut().insert(key, v) {
             Some(v) => {
@@ -191,10 +180,7 @@ pub mod HashMap_ {
         }
     }
 
-    pub fn remove<K, V: Clone>(map: HashMap<K, V>, k: K) -> bool
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn remove<K: Clone + 'static, V: Clone>(map: HashMap<K, V>, k: K) -> bool {
         let key = HashKey::new(k, map.comparer.clone());
         map.get_mut().remove(&key).is_some()
     }
@@ -203,10 +189,7 @@ pub mod HashMap_ {
         map.get_mut().clear();
     }
 
-    pub fn get<K, V: Clone>(map: HashMap<K, V>, k: K) -> V
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn get<K: Clone + 'static, V: Clone>(map: HashMap<K, V>, k: K) -> V {
         let key = HashKey::new(k, map.comparer.clone());
         match map.get_mut().get(&key) {
             Some(v) => v.clone(),
@@ -216,18 +199,16 @@ pub mod HashMap_ {
         }
     }
 
-    pub fn set<K, V: Clone>(map: HashMap<K, V>, k: K, v: V)
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn set<K: Clone + 'static, V: Clone>(map: HashMap<K, V>, k: K, v: V) {
         let key = HashKey::new(k, map.comparer.clone());
         map.get_mut().insert(key, v); // ignore return value
     }
 
-    pub fn tryGetValue<K, V: Clone>(map: HashMap<K, V>, k: K, res: &MutCell<V>) -> bool
-    where
-        K: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn tryGetValue<K: Clone + 'static, V: Clone>(
+        map: HashMap<K, V>,
+        k: K,
+        res: &MutCell<V>,
+    ) -> bool {
         let key = HashKey::new(k, map.comparer.clone());
         match map.get_mut().get(&key) {
             Some(v) => {
diff --git a/src/fable-library-rust/src/HashSet.rs b/src/fable-library-rust/src/HashSet.rs
index d35b3f811..7abd807e3 100644
--- a/src/fable-library-rust/src/HashSet.rs
+++ b/src/fable-library-rust/src/HashSet.rs
@@ -9,9 +9,10 @@ pub mod HashSet_ {
     #[cfg(not(feature = "no_std"))]
     use std::collections;
 
-    use crate::System::Collections::Generic::IEqualityComparer_1;
     use crate::NativeArray_::{array_from, Array};
     use crate::Native_::{mkRefMut, seq_to_iter, HashKey, Lrc, LrcPtr, MutCell, Seq, Vec};
+    use crate::System::Collections::Generic::EqualityComparer_1;
+    use crate::System::Collections::Generic::IEqualityComparer_1;
 
     use core::fmt::{Debug, Display, Formatter, Result};
     use core::hash::Hash;
@@ -21,10 +22,13 @@ pub mod HashSet_ {
     #[derive(Clone)] //, Debug, Default, PartialEq, PartialOrd, Eq, Hash, Ord)]
     pub struct HashSet<T: Clone> {
         hash_set: Lrc<MutHashSet<T>>,
-        comparer: Option<LrcPtr<dyn IEqualityComparer_1<T>>>,
+        comparer: LrcPtr<dyn IEqualityComparer_1<T>>,
     }
 
-    impl<T: Clone> Default for HashSet<T> {
+    impl<T> Default for HashSet<T>
+    where
+        T: Clone + Hash + PartialEq + 'static,
+    {
         fn default() -> HashSet<T> {
             new_empty()
         }
@@ -49,17 +53,14 @@ pub mod HashSet_ {
         }
     }
 
-    fn from_iter<T, I: Iterator<Item = T>>(
+    fn from_iter<T: Clone + 'static, I: Iterator<Item = T>>(
         iter: I,
-        comparer: Option<LrcPtr<dyn IEqualityComparer_1<T>>>,
-    ) -> HashSet<T>
-    where
-        T: Clone + Hash + PartialEq + 'static,
-    {
+        comparer: LrcPtr<dyn IEqualityComparer_1<T>>,
+    ) -> HashSet<T> {
         let it = iter.map(|v| HashKey::new(v, comparer.clone()));
         HashSet {
             hash_set: mkRefMut(collections::HashSet::from_iter(it)),
-            comparer: comparer.clone(),
+            comparer,
         }
     }
 
@@ -67,24 +68,30 @@ pub mod HashSet_ {
         set.iter().map(|k| k.key.clone())
     }
 
-    pub fn new_empty<T: Clone>() -> HashSet<T> {
+    pub fn new_empty<T>() -> HashSet<T>
+    where
+        T: Clone + Hash + PartialEq + 'static,
+    {
         HashSet {
             hash_set: mkRefMut(collections::HashSet::new()),
-            comparer: None,
+            comparer: EqualityComparer_1::<T>::get_Default(),
         }
     }
 
-    pub fn new_with_capacity<T: Clone>(capacity: i32) -> HashSet<T> {
+    pub fn new_with_capacity<T>(capacity: i32) -> HashSet<T>
+    where
+        T: Clone + Hash + PartialEq + 'static,
+    {
         HashSet {
             hash_set: mkRefMut(collections::HashSet::with_capacity(capacity as usize)),
-            comparer: None,
+            comparer: EqualityComparer_1::<T>::get_Default(),
         }
     }
 
     pub fn new_with_comparer<T: Clone>(comparer: LrcPtr<dyn IEqualityComparer_1<T>>) -> HashSet<T> {
         HashSet {
             hash_set: mkRefMut(collections::HashSet::new()),
-            comparer: Some(comparer),
+            comparer,
         }
     }
 
@@ -94,7 +101,7 @@ pub mod HashSet_ {
     ) -> HashSet<T> {
         HashSet {
             hash_set: mkRefMut(collections::HashSet::with_capacity(capacity as usize)),
-            comparer: Some(comparer),
+            comparer,
         }
     }
 
@@ -102,17 +109,14 @@ pub mod HashSet_ {
     where
         T: Clone + Hash + PartialEq + 'static,
     {
-        from_iter(seq_to_iter(&seq), None)
+        from_iter(seq_to_iter(&seq), EqualityComparer_1::<T>::get_Default())
     }
 
-    pub fn new_from_enumerable_comparer<T>(
+    pub fn new_from_enumerable_comparer<T: Clone + 'static>(
         seq: Seq<T>,
         comparer: LrcPtr<dyn IEqualityComparer_1<T>>,
-    ) -> HashSet<T>
-    where
-        T: Clone + Hash + PartialEq + 'static,
-    {
-        from_iter(seq_to_iter(&seq), Some(comparer))
+    ) -> HashSet<T> {
+        from_iter(seq_to_iter(&seq), comparer)
     }
 
     pub fn isReadOnly<T: Clone>(set: HashSet<T>) -> bool {
@@ -123,26 +127,17 @@ pub mod HashSet_ {
         set.len() as i32
     }
 
-    pub fn contains<T>(set: HashSet<T>, v: T) -> bool
-    where
-        T: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn contains<T: Clone + 'static>(set: HashSet<T>, v: T) -> bool {
         let key = HashKey::new(v, set.comparer.clone());
         set.contains(&key)
     }
 
-    pub fn add<T>(set: HashSet<T>, v: T) -> bool
-    where
-        T: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn add<T: Clone + 'static>(set: HashSet<T>, v: T) -> bool {
         let key = HashKey::new(v, set.comparer.clone());
         set.get_mut().insert(key)
     }
 
-    pub fn remove<T>(set: HashSet<T>, v: T) -> bool
-    where
-        T: Clone + Hash + PartialEq + 'static,
-    {
+    pub fn remove<T: Clone + 'static>(set: HashSet<T>, v: T) -> bool {
         let key = HashKey::new(v, set.comparer.clone());
         set.get_mut().remove(&key)
     }
diff --git a/src/fable-library-rust/src/Native.rs b/src/fable-library-rust/src/Native.rs
index 292fb2aed..69c0668ce 100644
--- a/src/fable-library-rust/src/Native.rs
+++ b/src/fable-library-rust/src/Native.rs
@@ -156,11 +156,11 @@ pub mod Native_ {
     #[derive(Clone)]
     pub struct HashKey<T: Clone> {
         pub key: T,
-        pub comparer: Option<LrcPtr<dyn IEqualityComparer_1<T>>>,
+        pub comparer: LrcPtr<dyn IEqualityComparer_1<T>>,
     }
 
     impl<T: Clone> HashKey<T> {
-        pub fn new(key: T, comparer: Option<LrcPtr<dyn IEqualityComparer_1<T>>>) -> HashKey<T> {
+        pub fn new(key: T, comparer: LrcPtr<dyn IEqualityComparer_1<T>>) -> HashKey<T> {
             HashKey { key, comparer }
         }
     }
@@ -177,27 +177,21 @@ pub mod Native_ {
         }
     }
 
-    impl<T: Clone + Hash + 'static> Hash for HashKey<T> {
+    impl<T: Clone + 'static> Hash for HashKey<T> {
         #[inline]
         fn hash<H: Hasher>(&self, state: &mut H) {
-            match &self.comparer {
-                Some(comp) => comp.GetHashCode(self.key.clone()).hash(state),
-                None => self.key.hash(state),
-            }
+            self.comparer.GetHashCode(self.key.clone()).hash(state)
         }
     }
 
-    impl<T: Clone + PartialEq + 'static> PartialEq for HashKey<T> {
+    impl<T: Clone + 'static> PartialEq for HashKey<T> {
         #[inline]
         fn eq(&self, other: &Self) -> bool {
-            match &self.comparer {
-                Some(comp) => comp.Equals(self.key.clone(), other.key.clone()),
-                None => self.key.eq(&other.key),
-            }
+            self.comparer.Equals(self.key.clone(), other.key.clone())
         }
     }
 
-    impl<T: Clone + Hash + PartialEq + 'static> Eq for HashKey<T> {}
+    impl<T: Clone + 'static> Eq for HashKey<T> {}
 
     // -----------------------------------------------------------
     // Type testing
diff --git a/src/fable-library-rust/src/System.Collections.Generic.fs b/src/fable-library-rust/src/System.Collections.Generic.fs
index 34f091306..d33fcedd5 100644
--- a/src/fable-library-rust/src/System.Collections.Generic.fs
+++ b/src/fable-library-rust/src/System.Collections.Generic.fs
@@ -2,9 +2,10 @@ namespace System.Collections.Generic
 
 open Global_
 
-type Comparer<'T when 'T: comparison>(comparison: 'T -> 'T -> int) =
+type Comparer<'T>(comparison: 'T -> 'T -> int) =
 
-    static member Default = Comparer<'T>(LanguagePrimitives.GenericComparison)
+    static member get_Default<'V when 'V: comparison>() =
+        Comparer<'V>(LanguagePrimitives.GenericComparison)
 
     static member Create(comparison) = Comparer<'T>(comparison)
 
@@ -13,10 +14,10 @@ type Comparer<'T when 'T: comparison>(comparison: 'T -> 'T -> int) =
     interface IComparer<'T> with
         member _.Compare(x, y) = comparison x y
 
-type EqualityComparer<'T when 'T: equality>(equals: 'T -> 'T -> bool, getHashCode: 'T -> int) =
+type EqualityComparer<'T>(equals: 'T -> 'T -> bool, getHashCode: 'T -> int) =
 
-    static member Default =
-        EqualityComparer<'T>(LanguagePrimitives.GenericEquality, LanguagePrimitives.GenericHash)
+    static member get_Default<'V when 'V: equality>() =
+        EqualityComparer<'V>(LanguagePrimitives.GenericEquality, LanguagePrimitives.GenericHash)
 
     static member Create(equals, getHashCode) =
         EqualityComparer<'T>(equals, getHashCode)