Change std to core where possible

Only one thing from std left: HashMap.

CHANGELOG.md

@@ -1,6 +1,6 @@
 # 1.0.0 (unreleased)
 
-- Removed `anymap::any::Any` in favour of just plain `std::any::Any`, since its
+- Removed `anymap::any::Any` in favour of just plain `core::any::Any`, since its
   `Send`/`Sync` story is now long stable.
 
   - This loses `Any + Sync`. `CloneAny + Sync` is also removed for consistency.

src/any.rs

@@ -1,10 +1,5 @@
-//! The different types of `Any` for use in a map.
-//!
-//! This stuff is all based on `std::any`, but goes a little further, with `CloneAny` being a
-//! cloneable `Any` and with the `Send` and `Sync` bounds possible on both `Any` and `CloneAny`.
-
-use std::fmt;
-use std::any::Any;
+use core::fmt;
+use core::any::Any;
 
 #[doc(hidden)]
 pub trait CloneToAny {
@@ -31,7 +26,7 @@ macro_rules! impl_clone {
                 // your bin crate needs a corresponding allow!). Although I explained my plight¹
                 // and it was all explained and agreed upon, no action has been taken. So I finally
                 // caved and worked around it by doing it this way, which matches what’s done for
-                // std::any², so it’s probably not *too* bad.
+                // core::any², so it’s probably not *too* bad.
                 //
                 // ¹ https://github.com/rust-lang/rust/issues/51443#issuecomment-421988013
                 // ² https://github.com/rust-lang/rust/blob/e7825f2b690c9a0d21b6f6d84c404bb53b151b38/library/alloc/src/boxed.rs#L1613-L1616
@@ -99,7 +94,7 @@ implement!(Any, + Send + Sync);
 /// [`Any`], but with cloning.
 ///
 /// Every type with no non-`'static` references that implements `Clone` implements `CloneAny`.
-/// See [`std::any`] for more details on `Any` in general.
+/// See [`core::any`] for more details on `Any` in general.
 pub trait CloneAny: Any + CloneToAny { }
 impl<T: Any + Clone> CloneAny for T { }
 implement!(CloneAny,);

src/lib.rs

@@ -4,8 +4,8 @@
 
 #![warn(missing_docs, unused_results)]
 
-use std::any::{Any, TypeId};
-use std::marker::PhantomData;
+use core::any::{Any, TypeId};
+use core::marker::PhantomData;
 
 use raw::RawMap;
 use any::{UncheckedAnyExt, IntoBox};
@@ -95,7 +95,7 @@ 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 `std::any::Any`, but there are other choices:
+/// be `core::any::Any` (also known as `std::any::Any`), but there are other choices:
 ///
 /// - If you want the entire map to be cloneable, use `CloneAny` instead of `Any`; with that, you
 ///   can only add types that implement `Clone` to the map.
@@ -104,9 +104,9 @@ pub mod raw;
 ///
 /// Cumulatively, there are thus six forms of map:
 ///
-/// - <code>[Map]&lt;dyn [std::any::Any]&gt;</code>, also spelled [`AnyMap`] for convenience.
-/// - <code>[Map]&lt;dyn [std::any::Any] + Send&gt;</code>
-/// - <code>[Map]&lt;dyn [std::any::Any] + Send + Sync&gt;</code>
+/// - <code>[Map]&lt;dyn [core::any::Any]&gt;</code>, also spelled [`AnyMap`] for convenience.
+/// - <code>[Map]&lt;dyn [core::any::Any] + Send&gt;</code>
+/// - <code>[Map]&lt;dyn [core::any::Any] + Send + Sync&gt;</code>
 /// - <code>[Map]&lt;dyn [CloneAny]&gt;</code>
 /// - <code>[Map]&lt;dyn [CloneAny] + Send&gt;</code>
 /// - <code>[Map]&lt;dyn [CloneAny] + Send + Sync&gt;</code>
@@ -114,7 +114,7 @@ pub mod raw;
 /// ## Example
 ///
 /// (Here using the [`AnyMap`] convenience alias; the first line could use
-/// <code>[anymap::Map][Map]::&lt;[std::any::Any]&gt;::new()</code> instead if desired.)
+/// <code>[anymap::Map][Map]::&lt;[core::any::Any]&gt;::new()</code> instead if desired.)
 ///
 /// ```rust
 /// let mut data = anymap::AnyMap::new();
@@ -444,7 +444,7 @@ mod tests {
         fn assert_send<T: Send>() { }
         fn assert_sync<T: Sync>() { }
         fn assert_clone<T: Clone>() { }
-        fn assert_debug<T: ::std::fmt::Debug>() { }
+        fn assert_debug<T: ::core::fmt::Debug>() { }
         assert_send::<Map<dyn Any + Send>>();
         assert_send::<Map<dyn Any + Send + Sync>>();
         assert_sync::<Map<dyn Any + Send + Sync>>();

src/raw.rs

@@ -2,15 +2,13 @@
 //!
 //! All relevant details are in the `RawMap` struct.
 
-use std::any::{Any, TypeId};
-use std::borrow::Borrow;
+use core::any::{Any, TypeId};
+use core::borrow::Borrow;
 use std::collections::hash_map::{self, HashMap};
-use std::convert::TryInto;
-use std::hash::Hash;
-use std::hash::{Hasher, BuildHasherDefault};
-#[cfg(test)]
-use std::mem;
-use std::ops::{Index, IndexMut};
+use core::convert::TryInto;
+use core::hash::Hash;
+use core::hash::{Hasher, BuildHasherDefault};
+use core::ops::{Index, IndexMut};
 
 use crate::any::UncheckedAnyExt;
 
@@ -41,7 +39,7 @@ fn type_id_hasher() {
         let mut hasher = TypeIdHasher::default();
         type_id.hash(&mut hasher);
         // SAFETY: u64 is valid for all bit patterns.
-        assert_eq!(hasher.finish(), unsafe { mem::transmute::<TypeId, u64>(type_id) });
+        assert_eq!(hasher.finish(), unsafe { core::mem::transmute::<TypeId, u64>(type_id) });
     }
     // Pick a variety of types, just to demonstrate it’s all sane. Normal, zero-sized, unsized, &c.
     verify_hashing_with(TypeId::of::<usize>());