summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorNadrieril2020-12-18 22:10:54 +0000
committerNadrieril2020-12-18 22:19:23 +0000
commit71ef15a3d41af43697b9c96feef80dd88425e7d4 (patch)
tree46cdc14c28ee206636177e028558f731555b07ee
parent66f79507ae5877d23ddd376b0b5cc7af5f2347bc (diff)
chore: convert doc links to intra-doc links
Diffstat (limited to '')
-rw-r--r--serde_dhall/src/deserialize.rs1
-rw-r--r--serde_dhall/src/lib.rs22
-rw-r--r--serde_dhall/src/options/de.rs48
-rw-r--r--serde_dhall/src/options/ser.rs36
-rw-r--r--serde_dhall/src/static_type.rs2
-rw-r--r--serde_dhall/src/value.rs10
6 files changed, 52 insertions, 67 deletions
diff --git a/serde_dhall/src/deserialize.rs b/serde_dhall/src/deserialize.rs
index 0e518ea..3fb06f9 100644
--- a/serde_dhall/src/deserialize.rs
+++ b/serde_dhall/src/deserialize.rs
@@ -84,7 +84,6 @@ impl<T> Sealed for T where T: serde::de::DeserializeOwned {}
/// # }
/// ```
///
-/// [`SimpleValue`]: enum.SimpleValue.html
pub fn from_simple_value<T>(v: SimpleValue) -> crate::Result<T>
where
T: serde::de::DeserializeOwned,
diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 01d036b..cd6affd 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -16,8 +16,8 @@
//!
//! ## Deserialization (reading)
//!
-//! The entrypoint for deserialization is the [`from_str`](fn.from_str.html) function. It reads a
-//! string containing a Dhall expression and deserializes it into any serde-compatible type.
+//! The entrypoint for deserialization is the [`from_str()`] function. It reads a string containing
+//! a Dhall expression and deserializes it into any serde-compatible type.
//!
//! This could mean a common Rust type like `HashMap`:
//!
@@ -66,8 +66,8 @@
//!
//! ## Serialization (writing)
//!
-//! The entrypoint for serialization is the [`serialize`](fn.serialize.html) function. It takes a
-//! serde-compatible type value and serializes it to a string containing a Dhall expression.
+//! The entrypoint for serialization is the [`serialize()`] function. It takes a serde-compatible
+//! type value and serializes it to a string containing a Dhall expression.
//!
//! This could mean a common Rust type like `HashMap`:
//!
@@ -116,9 +116,9 @@
//! # Replacing `serde_json` or `serde_yaml`
//!
//! If you used to consume JSON or YAML, you only need to replace [`serde_json::from_str`] or
-//! [`serde_yaml::from_str`] with [`serde_dhall::from_str(…).parse()`](fn.from_str.html).
+//! [`serde_yaml::from_str`] with [`serde_dhall::from_str(…).parse()`](from_str()).
//! If you used to produce JSON or YAML, you only need to replace [`serde_json::to_string`] or
-//! [`serde_yaml::to_string`] with [`serde_dhall::serialize(…).to_string()`](fn.serialize.html).
+//! [`serde_yaml::to_string`] with [`serde_dhall::serialize(…).to_string()`](serialize()).
//!
//! [`serde_json::from_str`]: https://docs.serde.rs/serde_json/fn.from_str.html
//! [`serde_yaml::from_str`]: https://docs.serde.rs/serde_yaml/fn.from_str.html
@@ -142,8 +142,8 @@
//! explicitly.
//!
//! There are two ways to provide a type in this way: you can provide it manually or you can let
-//! Rust infer it for you. To let Rust infer the appropriate Dhall type, use the
-//! [StaticType](trait.StaticType.html) trait.
+//! Rust infer it for you. To let Rust infer the appropriate Dhall type, use the [`StaticType`]
+//! trait.
//!
//! ```rust
//! # fn main() -> serde_dhall::Result<()> {
@@ -200,8 +200,8 @@
//! # }
//! ```
//!
-//! To provide a type manually, you need a [`SimpleType`](enum.SimpleType.html) value. You
-//! can parse it from some Dhall text like you would parse any other value.
+//! To provide a type manually, you need a [`SimpleType`] value. You can parse it from some Dhall
+//! text like you would parse any other value.
//!
//! ```rust
//! # fn main() -> serde_dhall::Result<()> {
@@ -249,8 +249,6 @@
//! If you need more control over the process of reading Dhall values, e.g. disabling
//! imports, see the [`Deserializer`] methods.
//!
-//! [`Deserializer`]: struct.Deserializer.html
-//! [`SimpleValue`]: enum.SimpleValue.html
//! [dhall]: https://dhall-lang.org/
//! [serde]: https://docs.serde.rs/serde/
//! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
diff --git a/serde_dhall/src/options/de.rs b/serde_dhall/src/options/de.rs
index 30846a2..103f161 100644
--- a/serde_dhall/src/options/de.rs
+++ b/serde_dhall/src/options/de.rs
@@ -19,15 +19,12 @@ enum Source<'a> {
/// This builder exposes the ability to configure how a value is deserialized and what operations
/// are permitted during evaluation.
///
-/// Generally speaking, when using [`Deserializer`], you'll create it with [`from_str`] or [`from_file`], then
-/// chain calls to methods to set each option, then call [`parse`]. This will give you a
-/// [`Result<T>`] where `T` is a deserializable type of your choice.
+/// Generally speaking, when using [`Deserializer`], you'll create it with [`from_str()`] or
+/// [`from_file()`], then chain calls to methods to set each option, then call [`parse()`]. This
+/// will give you a [`Result<T>`] where `T` is a deserializable type of your choice.
///
-/// [`Deserializer`]: struct.Deserializer.html
-/// [`from_str`]: fn.from_str.html
-/// [`from_file`]: fn.from_file.html
-/// [`parse`]: struct.Deserializer.html#method.parse
-/// [`Result<T>`]: type.Result.html
+/// [`parse()`]: Deserializer::parse()
+/// [`Result<T>`]: Result
///
/// # Examples
///
@@ -91,7 +88,7 @@ impl<'a> Deserializer<'a, NoAnnot> {
/// Ensures that the parsed value matches the provided type.
///
/// In many cases the Dhall type that corresponds to a Rust type can be inferred automatically.
- /// See the [`StaticType`] trait and the [`static_type_annotation`] method for that.
+ /// See the [`StaticType`] trait and the [`static_type_annotation()`] method for that.
///
/// # Example
///
@@ -124,8 +121,8 @@ impl<'a> Deserializer<'a, NoAnnot> {
/// # }
/// ```
///
- /// [`static_type_annotation`]: struct.Deserializer.html#method.static_type_annotation
- /// [`StaticType`]: trait.StaticType.html
+ /// [`StaticType`]: crate::StaticType
+ /// [`static_type_annotation()`]: Deserializer::static_type_annotation()
pub fn type_annotation<'ty>(
self,
ty: &'ty SimpleType,
@@ -139,8 +136,8 @@ impl<'a> Deserializer<'a, NoAnnot> {
/// Ensures that the parsed value matches the type of `T`.
///
- /// `T` must implement the [`StaticType`] trait. If it doesn't, you can use [`type_annotation`]
- /// to provide a type manually.
+ /// `T` must implement the [`StaticType`] trait. If it doesn't, you can use
+ /// [`type_annotation()`] to provide a type manually.
///
/// # Example
///
@@ -177,8 +174,8 @@ impl<'a> Deserializer<'a, NoAnnot> {
/// # }
/// ```
///
- /// [`type_annotation`]: struct.Deserializer.html#method.type_annotation
- /// [`StaticType`]: trait.StaticType.html
+ /// [`StaticType`]: crate::StaticType
+ /// [`type_annotation()`]: Deserializer::type_annotation()
pub fn static_type_annotation(self) -> Deserializer<'a, StaticAnnot> {
Deserializer {
annot: StaticAnnot,
@@ -210,9 +207,6 @@ impl<'a, A> Deserializer<'a, A> {
/// # Ok(())
/// # }
/// ```
- ///
- /// [`static_type_annotation`]: struct.Deserializer.html#method.static_type_annotation
- /// [`StaticType`]: trait.StaticType.html
pub fn imports(self, imports: bool) -> Self {
Deserializer {
allow_imports: imports,
@@ -271,7 +265,8 @@ impl<'a, A> Deserializer<'a, A> {
/// # Ok(())
/// # }
/// ```
- /// [`StaticType`]: trait.StaticType.html
+ ///
+ /// [`StaticType`]: crate::StaticType
pub fn parse<T>(&self) -> Result<T>
where
A: TypeAnnot,
@@ -287,7 +282,7 @@ impl<'a, A> Deserializer<'a, A> {
/// Deserialize a value from a string of Dhall text.
///
-/// This returns a [`Deserializer`] object. Call the [`parse`] method to get the deserialized
+/// This returns a [`Deserializer`] object. Call the [`parse()`] method to get the deserialized
/// value, or use other [`Deserializer`] methods to control the deserialization process.
///
/// Imports will be resolved relative to the current directory.
@@ -317,15 +312,14 @@ impl<'a, A> Deserializer<'a, A> {
/// # }
/// ```
///
-/// [`Deserializer`]: struct.Deserializer.html
-/// [`parse`]: struct.Deserializer.html#method.parse
+/// [`parse()`]: Deserializer::parse()
pub fn from_str(s: &str) -> Deserializer<'_, NoAnnot> {
Deserializer::from_str(s)
}
/// Deserialize a value from a Dhall file.
///
-/// This returns a [`Deserializer`] object. Call the [`parse`] method to get the deserialized
+/// This returns a [`Deserializer`] object. Call the [`parse()`] method to get the deserialized
/// value, or use other [`Deserializer`] methods to control the deserialization process.
///
/// Imports will be resolved relative to the provided file's path.
@@ -349,8 +343,7 @@ pub fn from_str(s: &str) -> Deserializer<'_, NoAnnot> {
/// # }
/// ```
///
-/// [`Deserializer`]: struct.Deserializer.html
-/// [`parse`]: struct.Deserializer.html#method.parse
+/// [`parse()`]: Deserializer::parse()
pub fn from_file<'a, P: AsRef<Path>>(path: P) -> Deserializer<'a, NoAnnot> {
Deserializer::from_file(path)
}
@@ -359,7 +352,7 @@ pub fn from_file<'a, P: AsRef<Path>>(path: P) -> Deserializer<'a, NoAnnot> {
/// the Dhall standard specification and is mostly used for caching expressions. Using the format
/// is not recommended because errors won't have a file to refer to and thus will be hard to fix.
///
-/// This returns a [`Deserializer`] object. Call the [`parse`] method to get the deserialized
+/// This returns a [`Deserializer`] object. Call the [`parse()`] method to get the deserialized
/// value, or use other [`Deserializer`] methods to control the deserialization process.
///
/// Imports will be resolved relative to the provided file's path.
@@ -383,8 +376,7 @@ pub fn from_file<'a, P: AsRef<Path>>(path: P) -> Deserializer<'a, NoAnnot> {
/// # }
/// ```
///
-/// [`Deserializer`]: struct.Deserializer.html
-/// [`parse`]: struct.Deserializer.html#method.parse
+/// [`parse()`]: Deserializer::parse()
pub fn from_binary_file<'a, P: AsRef<Path>>(
path: P,
) -> Deserializer<'a, NoAnnot> {
diff --git a/serde_dhall/src/options/ser.rs b/serde_dhall/src/options/ser.rs
index d74beb0..d2c173b 100644
--- a/serde_dhall/src/options/ser.rs
+++ b/serde_dhall/src/options/ser.rs
@@ -6,17 +6,14 @@ use crate::{Result, SimpleType, ToDhall};
/// This builder exposes the ability to configure how a value is serialized, and to set type
/// annotations.
///
-/// When using [`Serializer`], you'll create it with [`serialize`], then chain calls to methods to
-/// set each option, then call [`to_string`]. This will give you a [`Result<String>`] containing
-/// the input serialized to Dhall.
+/// When using [`Serializer`], you'll create it with [`serialize()`], then chain calls to methods
+/// to set each option, then call [`to_string()`]. This will give you a [`Result`] containing the
+/// input serialized to Dhall.
///
/// Note that if you do not provide a type annotation, some values may not be convertible to Dhall,
/// like empty lists or enums.
///
-/// [`Serializer`]: struct.Serializer.html
-/// [`serialize`]: fn.serialize.html
-/// [`to_string`]: struct.Serializer.html#method.to_string
-/// [`Result<String>`]: type.Result.html
+/// [`to_string()`]: Serializer::to_string()
///
/// # Examples
///
@@ -56,7 +53,7 @@ impl<'a, T> Serializer<'a, T, NoAnnot> {
/// unions.
///
/// In many cases the Dhall type that corresponds to a Rust type can be inferred automatically.
- /// See the [`StaticType`] trait and the [`static_type_annotation`] method for that.
+ /// See the [`StaticType`] trait and the [`static_type_annotation()`] method for that.
///
/// # Example
///
@@ -83,8 +80,8 @@ impl<'a, T> Serializer<'a, T, NoAnnot> {
/// # }
/// ```
///
- /// [`static_type_annotation`]: struct.Serializer.html#method.static_type_annotation
- /// [`StaticType`]: trait.StaticType.html
+ /// [`StaticType`]: crate::StaticType
+ /// [`static_type_annotation()`]: Serializer::static_type_annotation()
pub fn type_annotation<'ty>(
self,
ty: &'ty SimpleType,
@@ -98,7 +95,7 @@ impl<'a, T> Serializer<'a, T, NoAnnot> {
/// Uses the type of `T` in the serialization process. This will be used when Dhall needs it,
/// like for empty lists or for unions.
///
- /// `T` must implement the [`StaticType`] trait. If it doesn't, you can use [`type_annotation`]
+ /// `T` must implement the [`StaticType`] trait. If it doesn't, you can use [`type_annotation()`]
///
/// # Example
///
@@ -124,8 +121,8 @@ impl<'a, T> Serializer<'a, T, NoAnnot> {
/// # }
/// ```
///
- /// [`type_annotation`]: struct.Serializer.html#method.type_annotation
- /// [`StaticType`]: trait.StaticType.html
+ /// [`StaticType`]: crate::StaticType
+ /// [`type_annotation()`]: Serializer::type_annotation()
pub fn static_type_annotation(self) -> Serializer<'a, T, StaticAnnot> {
Serializer {
annot: StaticAnnot,
@@ -158,7 +155,7 @@ where
/// # }
/// ```
///
- /// [`StaticType`]: trait.StaticType.html
+ /// [`StaticType`]: crate::StaticType
pub fn to_string(&self) -> Result<String>
where
T: ToDhall + HasAnnot<A>,
@@ -170,11 +167,11 @@ where
/// Serialize a value to a string of Dhall text.
///
-/// This returns a [`Serializer`] object. Call the [`to_string`] method to get the serialized
+/// This returns a [`Serializer`] object. Call the [`to_string()`] method to get the serialized
/// value, or use other [`Serializer`] methods to control the serialization process.
///
/// In order to process certain values (like unions or empty lists) correctly, it is necessary to
-/// add a type annotation (with [`static_type_annotation`] or [`type_annotation`]).
+/// add a type annotation (with [`static_type_annotation()`] or [`type_annotation()`]).
///
/// # Examples
///
@@ -219,10 +216,9 @@ where
/// # }
/// ```
///
-/// [`Serializer`]: struct.Serializer.html
-/// [`type_annotation`]: struct.Serializer.html#method.type_annotation
-/// [`static_type_annotation`]: struct.Serializer.html#method.static_type_annotation
-/// [`to_string`]: struct.Serializer.html#method.to_string
+/// [`type_annotation()`]: Serializer::type_annotation()
+/// [`static_type_annotation()`]: Serializer::static_type_annotation()
+/// [`to_string()`]: Serializer::to_string()
pub fn serialize<T>(data: &T) -> Serializer<'_, T, NoAnnot>
where
T: ToDhall,
diff --git a/serde_dhall/src/static_type.rs b/serde_dhall/src/static_type.rs
index 586cd4d..31c93a6 100644
--- a/serde_dhall/src/static_type.rs
+++ b/serde_dhall/src/static_type.rs
@@ -12,7 +12,7 @@ use crate::SimpleType;
///
/// See also [the table of type correspondances].
///
-/// [the table of type correspondances]: enum.SimpleType.html#type-correspondence
+/// [the table of type correspondances]: SimpleType#type-correspondence
///
/// # Example
///
diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs
index b259c4b..df81a85 100644
--- a/serde_dhall/src/value.rs
+++ b/serde_dhall/src/value.rs
@@ -93,9 +93,9 @@ pub struct Value {
/// # }
/// ```
///
-/// [`from_str()`]: fn.from_str.html
-/// [`from_file()`]: fn.from_file.html
-/// [`from_simple_value()`]: fn.from_simple_value.html
+/// [`from_str()`]: crate::from_str()
+/// [`from_file()`]: crate::from_file()
+/// [`from_simple_value()`]: crate::from_simple_value()
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SimpleValue {
/// Numbers and booleans - `True`, `1`, `+2`, `3.24`
@@ -124,8 +124,8 @@ pub enum SimpleValue {
/// [`Deserializer::static_type_annotation`]. If you need to supply a `SimpleType` manually, you
/// can either deserialize it like any other Dhall value, or construct it manually.
///
-/// [`StaticType`]: trait.StaticType.html
-/// [`Deserializer::static_type_annotation`]: options/struct.Deserializer.html#method.static_type_annotation
+/// [`Deserializer::static_type_annotation`]: crate::Deserializer::static_type_annotation()
+/// [`StaticType`]: crate::StaticType
///
/// # Type correspondence
///