Move things around more

README.md

@@ -40,7 +40,7 @@ to use:
 
 ```toml
 [dependencies]
-musli = { version = "0.0.119", features = ["storage"] }
+musli = { version = "0.0.120", features = ["storage"] }
 ```
 
 <br>

crates/musli-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "musli-core"
-version = "0.0.119"
+version = "0.0.120"
 authors = ["John-John Tedro <udoprog@tedro.se>"]
 edition = "2021"
 rust-version = "1.76"
@@ -26,7 +26,7 @@ alloc = []
 verbose = ["musli-macros/verbose"]
 
 [dependencies]
-musli-macros = { version = "=0.0.119", path = "../musli-macros" }
+musli-macros = { version = "=0.0.120", path = "../musli-macros", features = [] }
 
 [dev-dependencies]
-musli = { version = "=0.0.119", path = "../musli" }
+musli = { version = "=0.0.120", path = "../musli" }

crates/musli-core/src/de/decode.rs

@@ -1,9 +1,5 @@
 use super::Decoder;
 
-/// Please refer to the main [musli documentation](https://docs.rs/musli).
-#[doc(inline)]
-pub use musli_macros::Decode;
-
 /// Trait governing how types are decoded.
 ///
 /// This is typically implemented automatically using the [`Decode` derive].
@@ -19,7 +15,7 @@ pub use musli_macros::Decode;
 /// struct MyType {
 ///     data: [u8; 128],
 /// }
-/// ````
+/// ```
 ///
 /// Implementing manually:
 ///

crates/musli-core/src/de/decode_bytes.rs

@@ -17,7 +17,7 @@ use super::Decoder;
 ///     #[musli(bytes)]
 ///     data: [u8; 128],
 /// }
-/// ````
+/// ```
 ///
 /// Implementing manually:
 ///

crates/musli-core/src/de/decode_packed.rs

@@ -20,7 +20,7 @@ use super::Decoder;
 ///     #[musli(packed)]
 ///     data: (u32, u32),
 /// }
-/// ````
+/// ```
 ///
 /// Implementing manually:
 ///

crates/musli-core/src/de/decoder.rs

@@ -45,7 +45,7 @@ pub trait Decoder<'de>: Sized {
     type DecodeVariant: VariantDecoder<'de, Cx = Self::Cx>;
 
     /// This is a type argument used to hint to any future implementor that they
-    /// should be using the [`#[musli::decoder]`][crate::decoder] attribute
+    /// should be using the [`#[musli::decoder]`][musli::decoder] attribute
     /// macro when implementing [`Decoder`].
     #[doc(hidden)]
     type __UseMusliDecoderAttributeMacro;

crates/musli-core/src/de/mod.rs

@@ -6,86 +6,94 @@
 //! itself. This also comes with a derive allowing you to derive high
 //! performance decoding associated with native Rust types.
 //!
+//! Note that using derives directly from `musli_core` requires you to use the
+//! `#[musli(crate = musli_core)]` attribute.
+//!
+//! # Examples
+//!
 //! ```
-//! use musli::Decode;
+//! use musli_core::Decode;
 //!
 //! #[derive(Decode)]
+//! #[musli(crate = musli_core)]
 //! pub struct Person<'a> {
 //!     name: &'a str,
 //!     age: u32,
 //! }
 //! ```
 
-mod skip;
-#[doc(inline)]
-pub use self::skip::Skip;
-
-mod size_hint;
+/// Derive which automatically implements the [`Decode` trait].
+///
+/// See the [`derives` module] for detailed documentation.
+///
+/// [`derives` module]: <https://docs.rs/musli/latest/musli/help/derives/index.html>
+/// [`Decode` trait]: trait@Decode
+///
+/// # Examples
+///
+/// ```
+/// use musli::Decode;
+///
+/// #[derive(Decode)]
+/// struct MyType {
+///     data: [u8; 128],
+/// }
+/// ```
 #[doc(inline)]
-pub use self::size_hint::SizeHint;
+pub use musli_macros::Decode;
 
 mod as_decoder;
-#[doc(inline)]
 pub use self::as_decoder::AsDecoder;
 
 mod decode;
-#[doc(inline)]
 pub use self::decode::Decode;
 
+mod decode_bytes;
+pub use self::decode_bytes::DecodeBytes;
+
+mod decode_packed;
+pub use self::decode_packed::DecodePacked;
+
 mod decode_trace;
-#[doc(inline)]
 pub use self::decode_trace::DecodeTrace;
 
 mod decode_unsized;
-#[doc(inline)]
 pub use self::decode_unsized::DecodeUnsized;
 
 mod decode_unsized_bytes;
-#[doc(inline)]
 pub use self::decode_unsized_bytes::DecodeUnsizedBytes;
 
-mod decode_bytes;
-#[doc(inline)]
-pub use self::decode_bytes::DecodeBytes;
-
-mod decode_packed;
-#[doc(inline)]
-pub use self::decode_packed::DecodePacked;
-
 mod decoder;
-#[doc(inline)]
 pub use self::decoder::Decoder;
 
-mod map_decoder;
-#[doc(inline)]
-pub use self::map_decoder::MapDecoder;
-
 mod entries_decoder;
-#[doc(inline)]
 pub use self::entries_decoder::EntriesDecoder;
 
 mod entry_decoder;
-#[doc(inline)]
 pub use self::entry_decoder::EntryDecoder;
 
+mod map_decoder;
+pub use self::map_decoder::MapDecoder;
+
 mod number_visitor;
-#[doc(inline)]
 pub use self::number_visitor::NumberVisitor;
 
 mod sequence_decoder;
-#[doc(inline)]
 pub use self::sequence_decoder::SequenceDecoder;
 
+mod size_hint;
+pub use self::size_hint::SizeHint;
+
+mod skip;
+pub use self::skip::Skip;
+
 mod value_visitor;
-#[doc(inline)]
 pub use self::value_visitor::ValueVisitor;
 
 mod variant_decoder;
-#[doc(inline)]
 pub use self::variant_decoder::VariantDecoder;
 
 mod visitor;
-#[doc(inline)]
 pub use self::visitor::Visitor;
 
 /// Decode to an owned value.

crates/musli-core/src/de/visitor.rs

@@ -24,7 +24,7 @@ pub trait Visitor<'de, C: ?Sized + Context>: Sized {
     type Number: NumberVisitor<'de, C, Ok = Self::Ok>;
 
     /// This is a type argument used to hint to any future implementor that they
-    /// should be using the [`#[musli::visitor]`][crate::visitor] attribute
+    /// should be using the [`#[musli::visitor]`][musli::visitor] attribute
     /// macro when implementing [`Visitor`].
     #[doc(hidden)]
     type __UseMusliVisitorAttributeMacro;

crates/musli-core/src/en/encode.rs

@@ -1,7 +1,5 @@
 use crate::en::Encoder;
 
-pub use musli_macros::Encode;
-
 /// Trait governing how types are encoded.
 ///
 /// This is typically implemented automatically using the [`Encode` derive].
@@ -17,7 +15,7 @@ pub use musli_macros::Encode;
 /// struct MyType {
 ///     data: [u8; 128],
 /// }
-/// ````
+/// ```
 ///
 /// Implementing manually:
 ///

crates/musli-core/src/en/encode_bytes.rs

@@ -17,7 +17,7 @@ use crate::en::Encoder;
 ///     #[musli(bytes)]
 ///     data: [u8; 128],
 /// }
-/// ````
+/// ```
 ///
 /// Implementing manually:
 ///

crates/musli-core/src/en/encode_packed.rs

@@ -20,7 +20,7 @@ use crate::en::Encoder;
 ///     #[musli(packed)]
 ///     data: (u32, u32),
 /// }
-/// ````
+/// ```
 ///
 /// Implementing manually:
 ///

crates/musli-core/src/en/encoder.rs

@@ -43,7 +43,7 @@ pub trait Encoder: Sized {
     type EncodeMapVariant: MapEncoder<Cx = Self::Cx, Ok = Self::Ok>;
 
     /// This is a type argument used to hint to any future implementor that they
-    /// should be using the [`#[musli::encoder]`][crate::encoder] attribute
+    /// should be using the [`#[musli::encoder]`][musli::encoder] attribute
     /// macro when implementing [`Encoder`].
     #[doc(hidden)]
     type __UseMusliEncoderAttributeMacro;

crates/musli-core/src/en/mod.rs

@@ -6,52 +6,68 @@
 //! also comes with a derive allowing you to derive high performance encoding
 //! associated with native Rust types.
 //!
+//! Note that using derives directly from `musli_core` requires you to use the
+//! `#[musli(crate = musli_core)]` attribute.
+//!
+//! # Examples
+//!
 //! ```
-//! use musli::Encode;
+//! use musli_core::Encode;
 //!
 //! #[derive(Encode)]
+//! #[musli(crate = musli_core)]
 //! pub struct Person<'a> {
 //!     name: &'a str,
 //!     age: u32,
 //! }
 //! ```
 
-mod encode;
+/// Derive which automatically implements the [`Encode` trait].
+///
+/// See the [`derives` module] for detailed documentation.
+///
+/// [`derives` module]: <https://docs.rs/musli/latest/musli/help/derives/index.html>
+/// [`Encode` trait]: trait@Encode
+///
+/// # Examples
+///
+/// ```
+/// use musli::Encode;
+///
+/// #[derive(Encode)]
+/// struct MyType {
+///     data: [u8; 128],
+/// }
+/// ```
 #[doc(inline)]
-pub use self::encode::Encode;
+pub use musli_macros::Encode;
 
-mod encode_trace;
-#[doc(inline)]
-pub use self::encode_trace::EncodeTrace;
+mod encode;
+pub use self::encode::Encode;
 
 mod encode_bytes;
-#[doc(inline)]
 pub use self::encode_bytes::EncodeBytes;
 
 mod encode_packed;
-#[doc(inline)]
 pub use self::encode_packed::EncodePacked;
 
+mod encode_trace;
+pub use self::encode_trace::EncodeTrace;
+
 mod encoder;
-#[doc(inline)]
 pub use self::encoder::Encoder;
 
-mod sequence_encoder;
-#[doc(inline)]
-pub use self::sequence_encoder::SequenceEncoder;
-
-mod map_encoder;
-#[doc(inline)]
-pub use self::map_encoder::MapEncoder;
+mod entries_encoder;
+pub use self::entries_encoder::EntriesEncoder;
 
 mod entry_encoder;
-#[doc(inline)]
 pub use self::entry_encoder::EntryEncoder;
 
-mod entries_encoder;
-#[doc(inline)]
-pub use self::entries_encoder::EntriesEncoder;
+mod map_encoder;
+pub use self::map_encoder::MapEncoder;
+
+mod sequence_encoder;
+pub use self::sequence_encoder::SequenceEncoder;
 
 mod variant_encoder;
-#[doc(inline)]
 pub use self::variant_encoder::VariantEncoder;