Drop anymap::Any in favour of std::any::Any

Casualties: Any + Sync, CloneAny + Sync. Acceptable losses.

CHANGELOG.md

@@ -1,7 +1,14 @@
 # 1.0.0 (unreleased)
 
-- **Breaking change:** `anymap::any` flattened out of existence:
+- Removed `anymap::any::Any` in favour of just plain `std::any::Any`, since its
-  `anymap::any::{Any, CloneAny}` are now found at `anymap::{Any, CloneAny}`.
+  `Send`/`Sync` story is now long stable.
+
+  - This loses `Any + Sync`. `CloneAny + Sync` is also removed for consistency.
+    (So `Any + Sync` is gone, but `Any`, `Any + Send` and `Any + Send + Sync`
+    remain, plus the same set for `CloneAny`.)
+
+- `anymap::any::CloneAny` moved to `anymap::CloneAny`.
+  With nothing public left in `anymap::any`, it is removed.
 
 - Relicensed from MIT/Apache-2.0 to BlueOak-1.0.0/MIT/Apache-2.0.
 

src/any.rs

@@ -4,7 +4,7 @@
 //! cloneable `Any` and with the `Send` and `Sync` bounds possible on both `Any` and `CloneAny`.
 
 use std::fmt;
-use std::any::Any as StdAny;
+use std::any::Any;
 
 #[doc(hidden)]
 pub trait CloneToAny {
@@ -40,6 +40,13 @@ macro_rules! impl_clone {
                 unsafe { Box::from_raw(raw as *mut $t) }
             }
         }
+
+        impl fmt::Debug for $t {
+            #[inline]
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.pad(stringify!($t))
+            }
+        }
     }
 }
 
@@ -59,13 +66,6 @@ pub trait IntoBox<A: ?Sized + UncheckedAnyExt>: Any {
 
 macro_rules! implement {
     ($base:ident, $(+ $bounds:ident)*) => {
-        impl fmt::Debug for dyn $base $(+ $bounds)* {
-            #[inline]
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.pad(stringify!(dyn $base $(+ $bounds)*))
-            }
-        }
-
         impl UncheckedAnyExt for dyn $base $(+ $bounds)* {
             #[inline]
             unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T {
@@ -92,48 +92,19 @@ macro_rules! implement {
     }
 }
 
-/// A type to emulate dynamic typing.
-///
-/// Every type with no non-`'static` references implements `Any`.
-/// See the [`std::any` documentation](https://doc.rust-lang.org/std/any/index.html) for
-/// more details on `Any` in general.
-///
-/// This trait is not `std::any::Any` but rather a type extending that for this library’s
-/// purposes so that it can be combined with marker traits like
-/// <code><a class=trait title=core::marker::Send
-/// href=http://doc.rust-lang.org/std/marker/trait.Send.html>Send</a></code> and
-/// <code><a class=trait title=core::marker::Sync
-/// href=http://doc.rust-lang.org/std/marker/trait.Sync.html>Sync</a></code>.
-///
-/// See also [`CloneAny`](trait.CloneAny.html) for a cloneable version of this trait.
-pub trait Any: StdAny { }
-impl<T: StdAny> Any for T { }
 implement!(Any,);
 implement!(Any, + Send);
-implement!(Any, + Sync);
 implement!(Any, + Send + Sync);
 
-/// A type to emulate dynamic typing with cloning.
+/// [`Any`], but with cloning.
 ///
-/// Every type with no non-`'static` references that implements `Clone` implements `Any`.
+/// Every type with no non-`'static` references that implements `Clone` implements `CloneAny`.
-/// See the [`std::any` documentation](https://doc.rust-lang.org/std/any/index.html) for
+/// See [`std::any`] for more details on `Any` in general.
-/// more details on `Any` in general.
-///
-/// This trait is not `std::any::Any` but rather a type extending that for this library’s
-/// purposes so that it can be combined with marker traits like
-/// <code><a class=trait title=core::marker::Send
-/// href=http://doc.rust-lang.org/std/marker/trait.Send.html>Send</a></code> and
-/// <code><a class=trait title=core::marker::Sync
-/// href=http://doc.rust-lang.org/std/marker/trait.Sync.html>Sync</a></code>.
-///
-/// See also [`Any`](trait.Any.html) for a version without the `Clone` requirement.
 pub trait CloneAny: Any + CloneToAny { }
-impl<T: StdAny + Clone> CloneAny for T { }
+impl<T: Any + Clone> CloneAny for T { }
 implement!(CloneAny,);
 implement!(CloneAny, + Send);
-implement!(CloneAny, + Sync);
 implement!(CloneAny, + Send + Sync);
 impl_clone!(dyn CloneAny);
 impl_clone!(dyn CloneAny + Send);
-impl_clone!(dyn CloneAny + Sync);
 impl_clone!(dyn CloneAny + Send + Sync);

src/lib.rs

@@ -2,12 +2,12 @@
 
 #![warn(missing_docs, unused_results)]
 
-use std::any::TypeId;
+use std::any::{Any, TypeId};
 use std::marker::PhantomData;
 
 use raw::RawMap;
 use any::{UncheckedAnyExt, IntoBox};
-pub use any::{Any, CloneAny};
+pub use any::CloneAny;
 
 macro_rules! impl_common_methods {
     (
@@ -93,10 +93,10 @@ pub mod raw;
 /// type-safe access to those values.
 ///
 /// The type parameter `A` allows you to use a different value type; normally you will want it to
-/// be `anymap::any::Any`, but there are other choices:
+/// be `std::any::Any`, but there are other choices:
 ///
 /// - If you want the entire map to be cloneable, use `CloneAny` instead of `Any`.
-/// - You can add on `+ Send` and/or `+ Sync` (e.g. `Map<dyn Any + Send>`) to add those bounds.
+/// - You can add on `+ Send` or `+ Send + Sync` (e.g. `Map<dyn Any + Send>`) to add those bounds.
 ///
 /// ```rust
 /// # use anymap::AnyMap;
@@ -312,8 +312,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox<A>> VacantEntry<'a, A, V> {
 
 #[cfg(test)]
 mod tests {
-    use {Map, AnyMap, Entry};
+    use super::*;
-    use any::{Any, CloneAny};
 
     #[derive(Clone, Debug, PartialEq)] struct A(i32);
     #[derive(Clone, Debug, PartialEq)] struct B(i32);
@@ -431,23 +430,18 @@ mod tests {
         fn assert_debug<T: ::std::fmt::Debug>() { }
         assert_send::<Map<dyn Any + Send>>();
         assert_send::<Map<dyn Any + Send + Sync>>();
-        assert_sync::<Map<dyn Any + Sync>>();
         assert_sync::<Map<dyn Any + Send + Sync>>();
         assert_debug::<Map<dyn Any>>();
         assert_debug::<Map<dyn Any + Send>>();
-        assert_debug::<Map<dyn Any + Sync>>();
         assert_debug::<Map<dyn Any + Send + Sync>>();
         assert_send::<Map<dyn CloneAny + Send>>();
         assert_send::<Map<dyn CloneAny + Send + Sync>>();
-        assert_sync::<Map<dyn CloneAny + Sync>>();
         assert_sync::<Map<dyn CloneAny + Send + Sync>>();
         assert_clone::<Map<dyn CloneAny + Send>>();
         assert_clone::<Map<dyn CloneAny + Send + Sync>>();
-        assert_clone::<Map<dyn CloneAny + Sync>>();
         assert_clone::<Map<dyn CloneAny + Send + Sync>>();
         assert_debug::<Map<dyn CloneAny>>();
         assert_debug::<Map<dyn CloneAny + Send>>();
-        assert_debug::<Map<dyn CloneAny + Sync>>();
         assert_debug::<Map<dyn CloneAny + Send + Sync>>();
     }
 }

src/raw.rs

@@ -2,7 +2,7 @@
 //!
 //! All relevant details are in the `RawMap` struct.
 
-use std::any::TypeId;
+use std::any::{Any, TypeId};
 use std::borrow::Borrow;
 use std::collections::hash_map::{self, HashMap};
 use std::convert::TryInto;
@@ -12,7 +12,7 @@ use std::hash::{Hasher, BuildHasherDefault};
 use std::mem;
 use std::ops::{Index, IndexMut};
 
-use any::{Any, UncheckedAnyExt};
+use any::UncheckedAnyExt;
 
 #[derive(Default)]
 struct TypeIdHasher {