Use Generic Associated Types for Enum trait

sugar700 · sugar700 · commit 4082f9fbb302 · 2023-04-04T17:46:48.000+02:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         toolchain:
-          - 1.61
+          - "1.65"
           - stable
           - beta
           - nightly
diff --git a/enum-map-derive/src/derive_enum.rs b/enum-map-derive/src/derive_enum.rs
@@ -37,7 +37,7 @@ impl EnumGenerator {
         quote! {
             #[automatically_derived]
             impl ::enum_map::Enum for #name {
-                const LENGTH: ::enum_map::usize = #length;
+                type Array<V> = [V; #length];
 
                 #[inline]
                 fn from_usize(value: ::enum_map::usize) -> Self {
@@ -53,11 +53,6 @@ impl EnumGenerator {
                     }
                 }
             }
-
-            #[automatically_derived]
-            impl<V> ::enum_map::EnumArray<V> for #name {
-                type Array = [V; #length];
-            }
         }
     }
 
diff --git a/enum-map-derive/src/derive_struct.rs b/enum-map-derive/src/derive_struct.rs
@@ -102,7 +102,7 @@ impl StructGenerator {
         quote! {
             #[automatically_derived]
             impl ::enum_map::Enum for #name {
-                const LENGTH: ::enum_map::usize = #length;
+                type Array<V> = [V; #length];
 
                 #[inline]
                 fn from_usize(value: ::enum_map::usize) -> Self {
@@ -114,11 +114,6 @@ impl StructGenerator {
                     #into_usize
                 }
             }
-
-            #[automatically_derived]
-            impl<V> ::enum_map::EnumArray<V> for #name {
-                type Array = [V; #length];
-            }
         }
     }
 }
diff --git a/enum-map-derive/src/lib.rs b/enum-map-derive/src/lib.rs
@@ -165,6 +165,6 @@ pub fn derive_enum_map(input: proc_macro::TokenStream) -> proc_macro::TokenStrea
 
 fn type_length(ty: &Type) -> TokenStream {
     quote! {
-        <#ty as ::enum_map::Enum>::LENGTH
+        ::enum_map::enum_len::<#ty>()
     }
 }
diff --git a/enum-map/Cargo.toml b/enum-map/Cargo.toml
@@ -3,7 +3,7 @@ name = "enum-map"
 version = "2.5.0"
 authors = ["Konrad Borowski <konrad@borowski.pw>"]
 edition = "2021"
-rust-version = "1.61"
+rust-version = "1.65"
 repository = "https://github.com/xfix/enum-map"
 license = "MIT OR Apache-2.0"
 description = "A map with C-like enum keys represented internally as an array"
diff --git a/enum-map/src/arbitrary.rs b/enum-map/src/arbitrary.rs
@@ -1,22 +1,24 @@
-use crate::{enum_map, EnumArray, EnumMap};
+use crate::internal::Array;
+use crate::{enum_map, Enum, EnumMap};
 use arbitrary::{Arbitrary, Result, Unstructured};
 
 /// Requires crate feature `"arbitrary"`
-impl<'a, K: EnumArray<V>, V: Arbitrary<'a>> Arbitrary<'a> for EnumMap<K, V> {
+impl<'a, K: Enum, V: Arbitrary<'a>> Arbitrary<'a> for EnumMap<K, V> {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<EnumMap<K, V>> {
         Ok(enum_map! {
             _ => Arbitrary::arbitrary(u)?,
         })
     }
 
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        if K::LENGTH == 0 {
+        let len = K::Array::<V>::LENGTH;
+        if len == 0 {
             (0, Some(0))
         } else {
             let (lo, hi) = V::size_hint(depth);
             (
-                lo.saturating_mul(K::LENGTH),
-                hi.and_then(|hi| hi.checked_mul(K::LENGTH)),
+                lo.saturating_mul(len),
+                hi.and_then(|hi| hi.checked_mul(len)),
             )
         }
     }
diff --git a/enum-map/src/enum_map_impls.rs b/enum-map/src/enum_map_impls.rs
@@ -1,16 +1,16 @@
-use crate::{enum_map, EnumArray, EnumMap};
+use crate::{enum_map, Enum, EnumMap};
 use core::fmt::{self, Debug, Formatter};
 use core::hash::{Hash, Hasher};
 use core::iter::{Extend, FromIterator};
 use core::ops::{Index, IndexMut};
 
-impl<K: EnumArray<V> + Debug, V: Debug> Debug for EnumMap<K, V> {
+impl<K: Enum + Debug, V: Debug> Debug for EnumMap<K, V> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.debug_map().entries(self).finish()
     }
 }
 
-impl<K: EnumArray<V>, V> Extend<(K, V)> for EnumMap<K, V> {
+impl<K: Enum, V> Extend<(K, V)> for EnumMap<K, V> {
     fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I) {
         for (key, value) in iter {
             self[key] = value;
@@ -20,7 +20,7 @@ impl<K: EnumArray<V>, V> Extend<(K, V)> for EnumMap<K, V> {
 
 impl<'a, K, V> Extend<(&'a K, &'a V)> for EnumMap<K, V>
 where
-    K: EnumArray<V> + Copy,
+    K: Enum + Copy,
     V: Copy,
 {
     fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I) {
@@ -31,7 +31,7 @@ where
 impl<K, V> FromIterator<(K, V)> for EnumMap<K, V>
 where
     Self: Default,
-    K: EnumArray<V>,
+    K: Enum,
 {
     fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
         let mut map = EnumMap::default();
@@ -40,7 +40,7 @@ where
     }
 }
 
-impl<K: EnumArray<V>, V> Index<K> for EnumMap<K, V> {
+impl<K: Enum, V> Index<K> for EnumMap<K, V> {
     type Output = V;
 
     #[inline]
@@ -49,7 +49,7 @@ impl<K: EnumArray<V>, V> Index<K> for EnumMap<K, V> {
     }
 }
 
-impl<K: EnumArray<V>, V> IndexMut<K> for EnumMap<K, V> {
+impl<K: Enum, V> IndexMut<K> for EnumMap<K, V> {
     #[inline]
     fn index_mut(&mut self, key: K) -> &mut V {
         &mut self.as_mut_slice()[key.into_usize()]
@@ -58,9 +58,9 @@ impl<K: EnumArray<V>, V> IndexMut<K> for EnumMap<K, V> {
 
 // Implementations provided by derive attribute are too specific, and put requirements on K.
 // This is caused by rust-lang/rust#26925.
-impl<K: EnumArray<V>, V> Clone for EnumMap<K, V>
+impl<K: Enum, V> Clone for EnumMap<K, V>
 where
-    K::Array: Clone,
+    K::Array<V>: Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -70,38 +70,38 @@ where
     }
 }
 
-impl<K: EnumArray<V>, V> Copy for EnumMap<K, V> where K::Array: Copy {}
+impl<K: Enum, V> Copy for EnumMap<K, V> where K::Array<V>: Copy {}
 
-impl<K: EnumArray<V>, V: PartialEq> PartialEq for EnumMap<K, V> {
+impl<K: Enum, V: PartialEq> PartialEq for EnumMap<K, V> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         self.as_slice() == other.as_slice()
     }
 }
 
-impl<K: EnumArray<V>, V: Eq> Eq for EnumMap<K, V> {}
+impl<K: Enum, V: Eq> Eq for EnumMap<K, V> {}
 
-impl<K: EnumArray<V>, V: Hash> Hash for EnumMap<K, V> {
+impl<K: Enum, V: Hash> Hash for EnumMap<K, V> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.as_slice().hash(state);
     }
 }
 
-impl<K: EnumArray<V>, V: Default> Default for EnumMap<K, V> {
+impl<K: Enum, V: Default> Default for EnumMap<K, V> {
     #[inline]
     fn default() -> Self {
         enum_map! { _ => V::default() }
     }
 }
 
-impl<K: EnumArray<V>, V: PartialOrd> PartialOrd for EnumMap<K, V> {
+impl<K: Enum, V: PartialOrd> PartialOrd for EnumMap<K, V> {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         self.as_slice().partial_cmp(other.as_slice())
     }
 }
 
-impl<K: EnumArray<V>, V: Ord> Ord for EnumMap<K, V> {
+impl<K: Enum, V: Ord> Ord for EnumMap<K, V> {
     fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.as_slice().cmp(other.as_slice())
     }
diff --git a/enum-map/src/internal.rs b/enum-map/src/internal.rs
@@ -9,44 +9,40 @@ use core::convert::Infallible;
 /// strictly speaking not an actual enum, there are good reasons to consider
 /// it like one, as array of `u8` keys is a relatively common pattern.
 pub trait Enum: Sized {
-    /// Length of the enum.
-    const LENGTH: usize;
+    /// Representation of an enum.
+    ///
+    /// For an enum with four elements it looks like this.
+    ///
+    /// ```
+    /// type Array<V> = [V; 4];
+    /// ```
+    type Array<V>: Array;
 
     /// Takes an usize, and returns an element matching `into_usize` function.
     fn from_usize(value: usize) -> Self;
     /// Returns an unique identifier for a value within range of `0..Array::LENGTH`.
     fn into_usize(self) -> usize;
 }
 
-/// Trait associating enum with an array.
-///
-/// This exists due to limitations of Rust compiler that prevent arrays from using
-/// associated constants in structures. The array length must match `LENGTH` of an
-/// `Enum`.
-pub trait EnumArray<V>: Enum {
-    /// Representation of an enum map for type `V`.
-    type Array: Array<V>;
-}
-
 /// Array for enum-map storage.
 ///
 /// This trait is inteded for primitive array types (with fixed length).
 ///
 /// # Safety
 ///
 /// The array length needs to match actual storage.
-pub unsafe trait Array<V> {
+pub unsafe trait Array {
     // This is necessary duplication because the length in Enum trait can be
     // provided by user and may not be trustworthy for unsafe code.
     const LENGTH: usize;
 }
 
-unsafe impl<V, const N: usize> Array<V> for [V; N] {
+unsafe impl<V, const N: usize> Array for [V; N] {
     const LENGTH: usize = N;
 }
 
 impl Enum for bool {
-    const LENGTH: usize = 2;
+    type Array<V> = [V; 2];
 
     #[inline]
     fn from_usize(value: usize) -> Self {
@@ -62,12 +58,8 @@ impl Enum for bool {
     }
 }
 
-impl<T> EnumArray<T> for bool {
-    type Array = [T; Self::LENGTH];
-}
-
 impl Enum for () {
-    const LENGTH: usize = 1;
+    type Array<V> = [V; 1];
 
     #[inline]
     fn from_usize(value: usize) -> Self {
@@ -82,12 +74,8 @@ impl Enum for () {
     }
 }
 
-impl<T> EnumArray<T> for () {
-    type Array = [T; Self::LENGTH];
-}
-
 impl Enum for u8 {
-    const LENGTH: usize = 256;
+    type Array<V> = [V; 256];
 
     #[inline]
     fn from_usize(value: usize) -> Self {
@@ -99,12 +87,8 @@ impl Enum for u8 {
     }
 }
 
-impl<T> EnumArray<T> for u8 {
-    type Array = [T; Self::LENGTH];
-}
-
 impl Enum for Infallible {
-    const LENGTH: usize = 0;
+    type Array<V> = [V; 0];
 
     #[inline]
     fn from_usize(_: usize) -> Self {
@@ -116,12 +100,8 @@ impl Enum for Infallible {
     }
 }
 
-impl<T> EnumArray<T> for Infallible {
-    type Array = [T; Self::LENGTH];
-}
-
 impl Enum for Ordering {
-    const LENGTH: usize = 3;
+    type Array<V> = [V; 3];
 
     #[inline]
     fn from_usize(value: usize) -> Self {
@@ -141,7 +121,3 @@ impl Enum for Ordering {
         }
     }
 }
-
-impl<T> EnumArray<T> for Ordering {
-    type Array = [T; Self::LENGTH];
-}
diff --git a/enum-map/src/iter.rs b/enum-map/src/iter.rs
diff --git a/enum-map/src/lib.rs b/enum-map/src/lib.rs
diff --git a/enum-map/src/serde.rs b/enum-map/src/serde.rs
diff --git a/enum-map/tests/test.rs b/enum-map/tests/test.rs

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ impl EnumGenerator {`
`37`	`37`	`quote! {`
`38`	`38`	`#[automatically_derived]`
`39`	`39`	`impl ::enum_map::Enum for #name {`
`40`		`- const LENGTH: ::enum_map::usize = #length;`
	`40`	`+ type Array<V> = [V; #length];`
`41`	`41`
`42`	`42`	`#[inline]`
`43`	`43`	`fn from_usize(value: ::enum_map::usize) -> Self {`
`@@ -53,11 +53,6 @@ impl EnumGenerator {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`}`
`56`		`-`
`57`		`- #[automatically_derived]`
`58`		`- impl<V> ::enum_map::EnumArray<V> for #name {`
`59`		`- type Array = [V; #length];`
`60`		`- }`
`61`	`56`	`}`
`62`	`57`	`}`
`63`	`58`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ impl StructGenerator {`
`102`	`102`	`quote! {`
`103`	`103`	`#[automatically_derived]`
`104`	`104`	`impl ::enum_map::Enum for #name {`
`105`		`- const LENGTH: ::enum_map::usize = #length;`
	`105`	`+ type Array<V> = [V; #length];`
`106`	`106`
`107`	`107`	`#[inline]`
`108`	`108`	`fn from_usize(value: ::enum_map::usize) -> Self {`
`@@ -114,11 +114,6 @@ impl StructGenerator {`
`114`	`114`	`#into_usize`
`115`	`115`	`}`
`116`	`116`	`}`
`117`		`-`
`118`		`- #[automatically_derived]`
`119`		`- impl<V> ::enum_map::EnumArray<V> for #name {`
`120`		`- type Array = [V; #length];`
`121`		`- }`
`122`	`117`	`}`
`123`	`118`	`}`
`124`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -165,6 +165,6 @@ pub fn derive_enum_map(input: proc_macro::TokenStream) -> proc_macro::TokenStrea`
`165`	`165`
`166`	`166`	`fn type_length(ty: &Type) -> TokenStream {`
`167`	`167`	`quote! {`
`168`		`- <#ty as ::enum_map::Enum>::LENGTH`
	`168`	`+ ::enum_map::enum_len::<#ty>()`
`169`	`169`	`}`
`170`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,24 @@`
`1`		`-use crate::{enum_map, EnumArray, EnumMap};`
	`1`	`+use crate::internal::Array;`
	`2`	`+use crate::{enum_map, Enum, EnumMap};`
`2`	`3`	`use arbitrary::{Arbitrary, Result, Unstructured};`
`3`	`4`
`4`	`5`	/// Requires crate feature `"arbitrary"`
`5`		`-impl<'a, K: EnumArray<V>, V: Arbitrary<'a>> Arbitrary<'a> for EnumMap<K, V> {`
	`6`	`+impl<'a, K: Enum, V: Arbitrary<'a>> Arbitrary<'a> for EnumMap<K, V> {`
`6`	`7`	`fn arbitrary(u: &mut Unstructured<'a>) -> Result<EnumMap<K, V>> {`
`7`	`8`	`Ok(enum_map! {`
`8`	`9`	`_ => Arbitrary::arbitrary(u)?,`
`9`	`10`	`})`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`fn size_hint(depth: usize) -> (usize, Option<usize>) {`
`13`		`- if K::LENGTH == 0 {`
	`14`	`+ let len = K::Array::<V>::LENGTH;`
	`15`	`+ if len == 0 {`
`14`	`16`	`(0, Some(0))`
`15`	`17`	`} else {`
`16`	`18`	`let (lo, hi) = V::size_hint(depth);`
`17`	`19`	`(`
`18`		`- lo.saturating_mul(K::LENGTH),`
`19`		`- hi.and_then(\|hi\| hi.checked_mul(K::LENGTH)),`
	`20`	`+ lo.saturating_mul(len),`
	`21`	`+ hi.and_then(\|hi\| hi.checked_mul(len)),`
`20`	`22`	`)`
`21`	`23`	`}`
`22`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,16 @@`
`1`		`-use crate::{enum_map, EnumArray, EnumMap};`
	`1`	`+use crate::{enum_map, Enum, EnumMap};`
`2`	`2`	`use core::fmt::{self, Debug, Formatter};`
`3`	`3`	`use core::hash::{Hash, Hasher};`
`4`	`4`	`use core::iter::{Extend, FromIterator};`
`5`	`5`	`use core::ops::{Index, IndexMut};`
`6`	`6`
`7`		`-impl<K: EnumArray<V> + Debug, V: Debug> Debug for EnumMap<K, V> {`
	`7`	`+impl<K: Enum + Debug, V: Debug> Debug for EnumMap<K, V> {`
`8`	`8`	`fn fmt(&self, f: &mut Formatter) -> fmt::Result {`
`9`	`9`	`f.debug_map().entries(self).finish()`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`
`13`		`-impl<K: EnumArray<V>, V> Extend<(K, V)> for EnumMap<K, V> {`
	`13`	`+impl<K: Enum, V> Extend<(K, V)> for EnumMap<K, V> {`
`14`	`14`	`fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I) {`
`15`	`15`	`for (key, value) in iter {`
`16`	`16`	`self[key] = value;`
`@@ -20,7 +20,7 @@ impl<K: EnumArray<V>, V> Extend<(K, V)> for EnumMap<K, V> {`
`20`	`20`
`21`	`21`	`impl<'a, K, V> Extend<(&'a K, &'a V)> for EnumMap<K, V>`
`22`	`22`	`where`
`23`		`- K: EnumArray<V> + Copy,`
	`23`	`+ K: Enum + Copy,`
`24`	`24`	`V: Copy,`
`25`	`25`	`{`
`26`	`26`	`fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I) {`
`@@ -31,7 +31,7 @@ where`
`31`	`31`	`impl<K, V> FromIterator<(K, V)> for EnumMap<K, V>`
`32`	`32`	`where`
`33`	`33`	`Self: Default,`
`34`		`- K: EnumArray<V>,`
	`34`	`+ K: Enum,`
`35`	`35`	`{`
`36`	`36`	`fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {`
`37`	`37`	`let mut map = EnumMap::default();`
`@@ -40,7 +40,7 @@ where`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`-impl<K: EnumArray<V>, V> Index<K> for EnumMap<K, V> {`
	`43`	`+impl<K: Enum, V> Index<K> for EnumMap<K, V> {`
`44`	`44`	`type Output = V;`
`45`	`45`
`46`	`46`	`#[inline]`
`@@ -49,7 +49,7 @@ impl<K: EnumArray<V>, V> Index<K> for EnumMap<K, V> {`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`-impl<K: EnumArray<V>, V> IndexMut<K> for EnumMap<K, V> {`
	`52`	`+impl<K: Enum, V> IndexMut<K> for EnumMap<K, V> {`
`53`	`53`	`#[inline]`
`54`	`54`	`fn index_mut(&mut self, key: K) -> &mut V {`
`55`	`55`	`&mut self.as_mut_slice()[key.into_usize()]`
`@@ -58,9 +58,9 @@ impl<K: EnumArray<V>, V> IndexMut<K> for EnumMap<K, V> {`
`58`	`58`
`59`	`59`	`// Implementations provided by derive attribute are too specific, and put requirements on K.`
`60`	`60`	`// This is caused by rust-lang/rust#26925.`
`61`		`-impl<K: EnumArray<V>, V> Clone for EnumMap<K, V>`
	`61`	`+impl<K: Enum, V> Clone for EnumMap<K, V>`
`62`	`62`	`where`
`63`		`- K::Array: Clone,`
	`63`	`+ K::Array<V>: Clone,`
`64`	`64`	`{`
`65`	`65`	`#[inline]`
`66`	`66`	`fn clone(&self) -> Self {`
`@@ -70,38 +70,38 @@ where`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`73`		`-impl<K: EnumArray<V>, V> Copy for EnumMap<K, V> where K::Array: Copy {}`
	`73`	`+impl<K: Enum, V> Copy for EnumMap<K, V> where K::Array<V>: Copy {}`
`74`	`74`
`75`		`-impl<K: EnumArray<V>, V: PartialEq> PartialEq for EnumMap<K, V> {`
	`75`	`+impl<K: Enum, V: PartialEq> PartialEq for EnumMap<K, V> {`
`76`	`76`	`#[inline]`
`77`	`77`	`fn eq(&self, other: &Self) -> bool {`
`78`	`78`	`self.as_slice() == other.as_slice()`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`		`-impl<K: EnumArray<V>, V: Eq> Eq for EnumMap<K, V> {}`
	`82`	`+impl<K: Enum, V: Eq> Eq for EnumMap<K, V> {}`
`83`	`83`
`84`		`-impl<K: EnumArray<V>, V: Hash> Hash for EnumMap<K, V> {`
	`84`	`+impl<K: Enum, V: Hash> Hash for EnumMap<K, V> {`
`85`	`85`	`#[inline]`
`86`	`86`	`fn hash<H: Hasher>(&self, state: &mut H) {`
`87`	`87`	`self.as_slice().hash(state);`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`-impl<K: EnumArray<V>, V: Default> Default for EnumMap<K, V> {`
	`91`	`+impl<K: Enum, V: Default> Default for EnumMap<K, V> {`
`92`	`92`	`#[inline]`
`93`	`93`	`fn default() -> Self {`
`94`	`94`	`enum_map! { _ => V::default() }`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-impl<K: EnumArray<V>, V: PartialOrd> PartialOrd for EnumMap<K, V> {`
	`98`	`+impl<K: Enum, V: PartialOrd> PartialOrd for EnumMap<K, V> {`
`99`	`99`	`fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {`
`100`	`100`	`self.as_slice().partial_cmp(other.as_slice())`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`-impl<K: EnumArray<V>, V: Ord> Ord for EnumMap<K, V> {`
	`104`	`+impl<K: Enum, V: Ord> Ord for EnumMap<K, V> {`
`105`	`105`	`fn cmp(&self, other: &Self) -> core::cmp::Ordering {`
`106`	`106`	`self.as_slice().cmp(other.as_slice())`
`107`	`107`	`}`