Break out transformer extension methods into their own package

LanguageExt.CodeGen/LanguageExt.CodeGen.csproj

@@ -7,7 +7,7 @@
   <!--<Sdk Name="CodeGeneration.Roslyn.Plugin.Sdk" Version="0.7.5-alpha" />-->
 
   <PropertyGroup>
-    <PackageVersion>4.1.1</PackageVersion>
+    <PackageVersion>4.1.2</PackageVersion>
     <PackageId>LanguageExt.CodeGen</PackageId>
     <Title>LanguageExt.CodeGen</Title>
     <TargetFramework>netstandard2.0</TargetFramework>
@@ -17,7 +17,7 @@
     <Copyright>Copyright (c) Paul Louth. All rights reserved.</Copyright>
     <Description>Design and build-time code-gen for records, unions, lenses and immutable With functions</Description>
     <PackageTags>C#, Functional, Language Extension, Lenses, Records, Unions, Monad, Option, Either, Reader, Writer, State, List, Set, Map, Queue, Memo, Memoization, Immutable, Lambda, Pattern Matching, Tuple</PackageTags>
-    <PackageIconUrl>https://github.com/louthy/language-ext/blob/master/Images/lang-ext-small.png?raw=true</PackageIconUrl>
+    <PackageIcon>lang-ext-small.png</PackageIcon>
     <PackageProjectUrl>https://github.com/louthy/language-ext</PackageProjectUrl>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
@@ -28,7 +28,12 @@
     <NoWarn>1701;1702;1705;IDE1006;CS1591;CS1573;CS1712;CS1570;CS1711;CS1572;CS1587</NoWarn>
 
   </PropertyGroup>
-
+  <ItemGroup>
+    <None Include="..\Images\lang-ext-small.png">
+      <Pack>True</Pack>
+      <PackagePath/>
+    </None>
+  </ItemGroup>
   <ItemGroup>
     <PackageReference Include="CodeGeneration.Roslyn" Version="$(RoslynCodeGenVersion)" />
   </ItemGroup>

LanguageExt.Core/Class Instances/Eq/EqSeq.cs

@@ -24,8 +24,6 @@ public struct EqSeq<EqA, A> : Eq<Seq<A>>
         [Pure]
         public bool Equals(Seq<A> x, Seq<A> y)
         {
-            if (x == null) return y == null;
-            if (y == null) return false;
             if (x.Count != y.Count) return false;
 
             while (true)

LanguageExt.Core/Class Instances/Indexable/SeqIndex.cs

@@ -13,7 +13,7 @@ public A Get(Seq<A> ma, int key) =>
 
         [Pure]
         public Option<A> TryGet(Seq<A> ma, int key) =>
-            ma == null || key < 0 || key >= ma.Count
+            key < 0 || key >= ma.Count
                 ? None
                 : Some(ma[key]);
     }

LanguageExt.Core/Class Instances/Ord/OrdSeq.cs

@@ -40,10 +40,6 @@ public bool Equals(Seq<A> x, Seq<A> y) =>
         [Pure]
         public int Compare(Seq<A> x, Seq<A> y)
         {
-            if (ReferenceEquals(x, y)) return 0;
-            if (ReferenceEquals(x, null)) return -1;
-            if (ReferenceEquals(y, null)) return 1;
-
             using var enumx = x.GetEnumerator();
             using var enumy = y.GetEnumerator();
 

LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.Eq.cs

@@ -1340,7 +1340,10 @@ public HashMap<EqK, K, V> ToHashMap() =>
         /// Map the map the a dictionary
         /// </summary>
         [Pure]
-        public IDictionary<KR, VR> ToDictionary<KR, VR>(Func<(K Key, V Value), KR> keySelector, Func<(K Key, V Value), VR> valueSelector) =>
+        public IDictionary<KR, VR> ToDictionary<KR, VR>(
+            Func<(K Key, V Value), KR> keySelector, 
+            Func<(K Key, V Value), VR> valueSelector) 
+            where KR : notnull =>
             AsEnumerable().ToDictionary(keySelector, valueSelector);
 
         /// <summary>
@@ -1926,15 +1929,15 @@ public Unit Union<W>(IEnumerable<(K Key, W Value)> rhs, WhenMissing<K, W, V> Map
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
-        public override bool Equals(object obj) =>
+        public override bool Equals(object? obj) =>
             obj is AtomHashMap<K, V> hm && Equals(hm);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
-        public bool Equals(AtomHashMap<EqK, K, V> other) =>
-            Items.Equals(other.Items);
+        public bool Equals(AtomHashMap<EqK, K, V>? other) =>
+            other is not null && Items.Equals(other.Items);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values

LanguageExt.Core/Concurrency/AtomHashMap/AtomHashMap.cs

@@ -1313,7 +1313,10 @@ public HashMap<K, V> ToHashMap() =>
         /// Map the map the a dictionary
         /// </summary>
         [Pure]
-        public IDictionary<KR, VR> ToDictionary<KR, VR>(Func<(K Key, V Value), KR> keySelector, Func<(K Key, V Value), VR> valueSelector) =>
+        public IDictionary<KR, VR> ToDictionary<KR, VR>(
+            Func<(K Key, V Value), KR> keySelector, 
+            Func<(K Key, V Value), VR> valueSelector) 
+            where KR : notnull =>
             AsEnumerable().ToDictionary(keySelector, valueSelector);
 
         /// <summary>
@@ -1898,15 +1901,15 @@ public Unit Union<W>(IEnumerable<(K Key, W Value)> rhs, WhenMissing<K, W, V> Map
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
-        public override bool Equals(object obj) =>
+        public override bool Equals(object? obj) =>
             obj is AtomHashMap<K, V> hm && Equals(hm);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
-        public bool Equals(AtomHashMap<K, V> other) =>
-            Items.Equals(other.Items);
+        public bool Equals(AtomHashMap<K, V>? other) =>
+            other is not null && Items.Equals(other.Items);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values

LanguageExt.Core/Concurrency/AtomSeq/AtomSeq.cs

@@ -1070,7 +1070,7 @@ public override int GetHashCode() =>
 
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int CompareTo(object obj) => obj switch 
+        public int CompareTo(object? obj) => obj switch 
         {
             AtomSeq<A>     s => CompareTo(s),
             Seq<A>         s => CompareTo(s),
@@ -1150,7 +1150,7 @@ public string ToFullArrayString(string separator = ", ") =>
         /// Equality test
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public override bool Equals(object obj) => obj switch 
+        public override bool Equals(object? obj) => obj switch 
         {
             AtomSeq<A>     s => Equals(s),
             Seq<A>         s => Equals(s),
@@ -1171,8 +1171,8 @@ public bool Equals(Seq<A> rhs) =>
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Equals(AtomSeq<A> rhs) =>
-            Equals<EqDefault<A>>(rhs);
+        public bool Equals(AtomSeq<A>? rhs) =>
+            rhs is not null && Equals<EqDefault<A>>(rhs);
 
         /// <summary>
         /// Equality test
@@ -1436,8 +1436,10 @@ public int CompareTo(Seq<A> rhs) =>
         /// Compare to another sequence
         /// </summary>
         [Pure]
-        public int CompareTo(AtomSeq<A> rhs) =>
-            CompareTo<OrdDefault<A>>(rhs);
+        public int CompareTo(AtomSeq<A>? rhs) =>
+            rhs is null 
+                ? 1
+                : CompareTo<OrdDefault<A>>(rhs);
 
         /// <summary>
         /// Compare to another sequence

LanguageExt.Core/Concurrency/ValueTask/ValueTask.Extensions.cs

@@ -286,7 +286,6 @@ class PropCache<T>
 
         public static async ValueTask<A> Cast<A>(this ValueTask source)
         {
-            if (source == null) throw new ArgumentNullException(nameof(source));
             await source.ConfigureAwait(false);
             var prop = PropCache<A>.Info;
             return prop != null

LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.K.V.cs

@@ -372,16 +372,16 @@ public Unit Except(IEnumerable<K> rhs) =>
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public override bool Equals(object obj) =>
+        public override bool Equals(object? obj) =>
             obj is VersionHashMap<ConflictV, K, V> hm && Equals(hm);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Equals(VersionHashMap<ConflictV, K, V> other) =>
-            Items.Equals(other.Items);
+        public bool Equals(VersionHashMap<ConflictV, K, V>? other) =>
+            other is not null && Items.Equals(other.Items);
 
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.ConflictV.OrdActor.EqK.Actor.K.V.cs

@@ -460,16 +460,16 @@ public Unit Except(IEnumerable<K> rhs)
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public override bool Equals(object obj) =>
+        public override bool Equals(object? obj) =>
             obj is VersionHashMap<ConflictV, OrdActor, EqK, Actor, K, V> hm && Equals(hm);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Equals(VersionHashMap<ConflictV, OrdActor, EqK, Actor, K, V> other) =>
-            Items.Equals(other.Items);
+        public bool Equals(VersionHashMap<ConflictV, OrdActor, EqK, Actor, K, V>? other) =>
+            other is not null && Items.Equals(other.Items);
 
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

LanguageExt.Core/Concurrency/VersionHashMap/VersionHashMap.K.V.cs

@@ -371,16 +371,16 @@ public Unit Except(IEnumerable<K> rhs) =>
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public override bool Equals(object obj) =>
+        public override bool Equals(object? obj) =>
             obj is VersionHashMap<K, V> hm && Equals(hm);
 
         /// <summary>
         /// Equality of keys and values with `EqDefault<V>` used for values
         /// </summary>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Equals(VersionHashMap<K, V> other) =>
-            Items.Equals(other.Items);
+        public bool Equals(VersionHashMap<K, V>? other) =>
+            other is not null && Items.Equals(other.Items);
 
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]