hilarious and original jokeHEADmain

8 files changed, 183 insertions, 183 deletions

diff --git a/src/datetime.rs b/src/datetime.rs
index 1f68bfd..2445c48 100644
--- a/src/datetime.rs
+++ b/src/datetime.rs
@@ -4,22 +4,22 @@ use std::str::{self, FromStr};
 
 use serde::{de, ser};
 
-/// A parsed TOML datetime value
+/// A parsed MILF datetime value
 ///
 /// This structure is intended to represent the datetime primitive type that can
-/// be encoded into TOML documents. This type is a parsed version that contains
+/// be encoded into MILF documents. This type is a parsed version that contains
 /// all metadata internally.
 ///
 /// Currently this type is intentionally conservative and only supports
 /// `to_string` as an accessor. Over time though it's intended that it'll grow
 /// more support!
 ///
-/// Note that if you're using `Deserialize` to deserialize a TOML document, you
+/// Note that if you're using `Deserialize` to deserialize a MILF document, you
 /// can use this as a placeholder for where you're expecting a datetime to be
 /// specified.
 ///
 /// Also note though that while this type implements `Serialize` and
-/// `Deserialize` it's only recommended to use this type with the TOML format,
+/// `Deserialize` it's only recommended to use this type with the MILF format,
 /// otherwise encoded in other formats it may look a little odd.
 #[derive(PartialEq, Clone)]
 pub struct Datetime {
@@ -38,10 +38,10 @@ pub struct DatetimeParseError {
 // to a special valid in the serde data model. Namely one with these special
 // fields/struct names.
 //
-// In general the TOML encoder/decoder will catch this and not literally emit
+// In general the MILF encoder/decoder will catch this and not literally emit
 // these strings but rather emit datetimes as they're intended.
-pub const FIELD: &str = "$__toml_private_datetime";
-pub const NAME: &str = "$__toml_private_Datetime";
+pub const FIELD: &str = "$__milf_private_datetime";
+pub const NAME: &str = "$__milf_private_Datetime";
 
 #[derive(PartialEq, Clone)]
 struct Date {
@@ -329,7 +329,7 @@ impl<'de> de::Deserialize<'de> for Datetime {
             type Value = Datetime;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a TOML datetime")
+                formatter.write_str("a MILF datetime")
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Datetime, V::Error>
diff --git a/src/de.rs b/src/de.rs
index 6411293..31904b5 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -1,6 +1,6 @@
-//! Deserializing TOML into Rust structures.
+//! Deserializing MILF into Rust structures.
 //!
-//! This module contains all the Serde support for deserializing TOML documents
+//! This module contains all the Serde support for deserializing MILF documents
 //! into Rust structures. Note that some top-level functions here are also
 //! provided at the top of the crate.
 
@@ -22,13 +22,13 @@ use crate::datetime;
 use crate::spanned;
 use crate::tokens::{Error as TokenError, Span, Token, Tokenizer};
 
-/// Type Alias for a TOML Table pair
+/// Type Alias for a MILF Table pair
 type TablePair<'a> = ((Span, Cow<'a, str>), Value<'a>);
 
 /// Deserializes a byte slice into a type.
 ///
 /// This function will attempt to interpret `bytes` as UTF-8 data and then
-/// deserialize `T` from the TOML document provided.
+/// deserialize `T` from the MILF document provided.
 pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
 where
     T: de::Deserialize<'de>,
@@ -41,7 +41,7 @@ where
 
 /// Deserializes a string into a type.
 ///
-/// This function will attempt to interpret `s` as a TOML document and
+/// This function will attempt to interpret `s` as a MILF document and
 /// deserialize `T` from the document.
 ///
 /// # Examples
@@ -61,14 +61,14 @@ where
 /// }
 ///
 /// fn main() {
-///     let config: Config = toml::from_str(r#"
-///         title = 'TOML Example'
+///     let config: Config = milf::from_str(r#"
+///         title = 'MILF Example'
 ///
 ///         [owner]
 ///         name = 'Lisa'
 ///     "#).unwrap();
 ///
-///     assert_eq!(config.title, "TOML Example");
+///     assert_eq!(config.title, "MILF Example");
 ///     assert_eq!(config.owner.name, "Lisa");
 /// }
 /// ```
@@ -198,7 +198,7 @@ enum ErrorKind {
     __Nonexhaustive,
 }
 
-/// Deserialization implementation for TOML.
+/// Deserialization implementation for MILF.
 pub struct Deserializer<'a> {
     require_newline_after_table: bool,
     allow_duplciate_after_longer_table: bool,
@@ -231,7 +231,7 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
             de: self,
         });
         res.map_err(|mut err| {
-            // Errors originating from this library (toml), have an offset
+            // Errors originating from this library (milf), have an offset
             // attached to them already. Other errors, like those originating
             // from serde (like "missing field") or from a custom deserializer,
             // do not have offsets on them. Here, we do a best guess at their
@@ -444,7 +444,7 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
             self.cur = pos;
 
             // Test to see if we're duplicating our parent's table, and if so
-            // then this is an error in the toml format
+            // then this is an error in the milf format
             if self.cur_parent != pos {
                 if headers_equal(
                     &self.tables[self.cur_parent].header,
@@ -647,7 +647,7 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
             && !(self.array && !self.values.peek().is_none())
         {
             // TODO we can't actually emit spans here for the *entire* table/array
-            // due to the format that toml uses. Setting the start and end to 0 is
+            // due to the format that milf uses. Setting the start and end to 0 is
             // *detectable* (and no reasonable span would look like that),
             // it would be better to expose this in the API via proper
             // ADTs like Option<T>.
@@ -1283,22 +1283,22 @@ impl<'a> Deserializer<'a> {
         Ok(())
     }
 
-    /// Historical versions of toml-rs accidentally allowed a newline after a
-    /// table definition, but the TOML spec requires a newline after a table
+    /// Historical versions of milf-rs accidentally allowed a newline after a
+    /// table definition, but the MILF spec requires a newline after a table
     /// definition header.
     ///
     /// This option can be set to `false` (the default is `true`) to emulate
-    /// this behavior for backwards compatibility with older toml-rs versions.
+    /// this behavior for backwards compatibility with older milf-rs versions.
     pub fn set_require_newline_after_table(&mut self, require: bool) {
         self.require_newline_after_table = require;
     }
 
-    /// Historical versions of toml-rs accidentally allowed a duplicate table
+    /// Historical versions of milf-rs accidentally allowed a duplicate table
     /// header after a longer table header was previously defined. This is
-    /// invalid according to the TOML spec, however.
+    /// invalid according to the MILF spec, however.
     ///
     /// This option can be set to `true` (the default is `false`) to emulate
-    /// this behavior for backwards compatibility with older toml-rs versions.
+    /// this behavior for backwards compatibility with older milf-rs versions.
     pub fn set_allow_duplicate_after_longer_table(&mut self, allow: bool) {
         self.allow_duplciate_after_longer_table = allow;
     }
@@ -2148,7 +2148,7 @@ impl fmt::Display for Error {
             )?,
             ErrorKind::UnquotedString => write!(
                 f,
-                "invalid TOML value, did you mean to use a quoted string?"
+                "invalid MILF value, did you mean to use a quoted string?"
             )?,
             ErrorKind::__Nonexhaustive => panic!(),
         }
diff --git a/src/lib.rs b/src/lib.rs
index 00421b1..bb49225 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,14 +1,14 @@
-//! A [TOML]-parsing library
+//! A [My INI-Like Format (MILF)]-parsing library
 //!
-//! This library implements a [TOML] v0.5.0 compatible parser,
+//! This library implements a [MILF] v0.5.0 compatible parser,
 //! primarily supporting the [`serde`] library for encoding/decoding
 //! various types in Rust.
 //!
-//! TOML itself is a simple, ergonomic, and readable configuration format:
+//! MILF itself is a simple, ergonomic, and readable configuration format:
 //!
 //! ```toml
 //! [package]
-//! name = "toml"
+//! name = "milf"
 //! version = "0.4.2"
 //! authors = ["Alex Crichton <alex@alexcrichton.com>"]
 //!
@@ -16,12 +16,12 @@
 //! serde = "1.0"
 //! ```
 //!
-//! The TOML format tends to be relatively common throughout the Rust community
+//! The MILF format tends to be relatively common throughout the Rust community
 //! for configuration, notably being used by [Cargo], Rust's package manager.
 //!
-//! ## TOML values
+//! ## MILF values
 //!
-//! A value in TOML is represented with the [`Value`] enum in this crate:
+//! A value in MILF is represented with the [`Value`] enum in this crate:
 //!
 //! ```rust,ignore
 //! pub enum Value {
@@ -35,16 +35,16 @@
 //! }
 //! ```
 //!
-//! TOML is similar to JSON with the notable addition of a [`Datetime`]
-//! type. In general, TOML and JSON are interchangeable in terms of
+//! MILF is similar to JSON with the notable addition of a [`Datetime`]
+//! type. In general, MILF and JSON are interchangeable in terms of
 //! formats.
 //!
-//! ## Parsing TOML
+//! ## Parsing MILF
 //!
-//! The easiest way to parse a TOML document is via the [`Value`] type:
+//! The easiest way to parse a MILF document is via the [`Value`] type:
 //!
 //! ```rust
-//! use toml::Value;
+//! use milf::Value;
 //!
 //! let value = "foo = 'bar'".parse::<Value>().unwrap();
 //!
@@ -74,7 +74,7 @@
 //! use the [`Deserializer`], [`Serializer`], or [`Value`] type itself to act as
 //! a deserializer/serializer for arbitrary types.
 //!
-//! An example of deserializing with TOML is:
+//! An example of deserializing with MILF is:
 //!
 //! ```rust
 //! use serde_derive::Deserialize;
@@ -93,7 +93,7 @@
 //! }
 //!
 //! fn main() {
-//!     let config: Config = toml::from_str(r#"
+//!     let config: Config = milf::from_str(r#"
 //!         ip = '127.0.0.1'
 //!
 //!         [keys]
@@ -136,15 +136,15 @@
 //!         },
 //!     };
 //!
-//!     let toml = toml::to_string(&config).unwrap();
+//!     let milf = milf::to_string(&config).unwrap();
 //! }
 //! ```
 //!
-//! [TOML]: https://github.com/toml-lang/toml
+//! [MILF]: https://github.com/toml-lang/toml
 //! [Cargo]: https://crates.io/
 //! [`serde`]: https://serde.rs/
 
-#![doc(html_root_url = "https://docs.rs/toml/0.5")]
+#![doc(html_root_url = "https://docs.rs/milf/0.5")]
 #![deny(missing_docs)]
 #![warn(rust_2018_idioms)]
 // Makes rustc abort compilation if there are any unsafe blocks in the crate.
diff --git a/src/macros.rs b/src/macros.rs
index 0731afe..ed719ae 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -2,15 +2,15 @@ pub use serde::de::{Deserialize, IntoDeserializer};
 
 use crate::value::{Array, Table, Value};
 
-/// Construct a [`toml::Value`] from TOML syntax.
+/// Construct a [`milf::Value`] from MILF syntax.
 ///
-/// [`toml::Value`]: value/enum.Value.html
+/// [`milf::Value`]: value/enum.Value.html
 ///
 /// ```rust
 /// fn main() {
-///     let cargo_toml = toml::toml! {
+///     let cargo_milf = milf::milf! {
 ///         [package]
-///         name = "toml"
+///         name = "milf"
 ///         version = "0.4.5"
 ///         authors = ["Alex Crichton <alex@alexcrichton.com>"]
 ///
@@ -25,20 +25,20 @@ use crate::value::{Array, Table, Value};
 ///         serde_json = "1.0"
 ///     };
 ///
-///     println!("{:#?}", cargo_toml);
+///     println!("{:#?}", cargo_milf);
 /// }
 /// ```
 #[macro_export]
-macro_rules! toml {
-    ($($toml:tt)+) => {{
+macro_rules! milf {
+    ($($milf:tt)+) => {{
         let table = $crate::value::Table::new();
         let mut root = $crate::Value::Table(table);
-        $crate::toml_internal!(@toplevel root [] $($toml)+);
+        $crate::milf_internal!(@toplevel root [] $($milf)+);
         root
     }};
 }
 
-// TT-muncher to parse TOML syntax into a toml::Value.
+// TT-muncher to parse MILF syntax into a milf::Value.
 //
 //    @toplevel -- Parse tokens outside of an inline table or inline array. In
 //                 this state, `[table headers]` and `[[array headers]]` are
@@ -55,13 +55,13 @@ macro_rules! toml {
 //                 primitive or inline table or inline array.
 //
 //    @table -- Parse the contents of an inline table, returning them as a
-//                 toml::Value::Table.
+//                 milf::Value::Table.
 //
 //    @tabledatetime -- Helper to parse a Datetime from string and insert it
 //                 into a table, continuing in the @table state.
 //
 //    @array -- Parse the contents of an inline array, returning them as a
-//                 toml::Value::Array.
+//                 milf::Value::Array.
 //
 //    @arraydatetime -- Helper to parse a Datetime from string and push it into
 //                 an array, continuing in the @array state.
@@ -72,105 +72,105 @@ macro_rules! toml {
 //
 #[macro_export]
 #[doc(hidden)]
-macro_rules! toml_internal {
+macro_rules! milf_internal {
     // Base case, no elements remaining.
     (@toplevel $root:ident [$($path:tt)*]) => {};
 
     // Parse negative number `key = -value`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = - $v:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($($k)-+).+ = (-$v) $($rest)*);
+        $crate::milf_internal!(@toplevel $root [$($path)*] $($($k)-+).+ = (-$v) $($rest)*);
     };
 
     // Parse positive number `key = +value`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = + $v:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($($k)-+).+ = ($v) $($rest)*);
+        $crate::milf_internal!(@toplevel $root [$($path)*] $($($k)-+).+ = ($v) $($rest)*);
     };
 
     // Parse offset datetime `key = 1979-05-27T00:32:00.999999-07:00`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
     };
     // Space instead of T.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
     };
 
     // Parse offset datetime `key = 1979-05-27T00:32:00-07:00`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
     };
     // Space instead of T.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
     };
 
     // Parse local datetime `key = 1979-05-27T00:32:00.999999`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
     };
     // Space instead of T.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
     };
 
     // Parse offset datetime `key = 1979-05-27T07:32:00Z` and local datetime `key = 1979-05-27T07:32:00`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec) $($rest)*);
     };
     // Space instead of T.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
     };
 
     // Parse local date `key = 1979-05-27`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day) $($rest)*);
     };
 
     // Parse local time `key = 00:32:00.999999`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt . $frac:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($hr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($hr : $min : $sec . $frac) $($rest)*);
     };
 
     // Parse local time `key = 07:32:00`.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($hr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($hr : $min : $sec) $($rest)*);
     };
 
     // Parse any other `key = value` including string, inline array, inline
     // table, number, and boolean.
     (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $v:tt $($rest:tt)*) => {{
-        $crate::macros::insert_toml(
+        $crate::macros::insert_milf(
             &mut $root,
-            &[$($path)* $(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
-            $crate::toml_internal!(@value $v));
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($rest)*);
+            &[$($path)* $(&concat!($("-", $crate::milf_internal!(@path $k),)+)[1..], )+],
+            $crate::milf_internal!(@value $v));
+        $crate::milf_internal!(@toplevel $root [$($path)*] $($rest)*);
     }};
 
     // Parse array header `[[bin]]`.
     (@toplevel $root:ident $oldpath:tt [[$($($path:tt)-+).+]] $($rest:tt)*) => {
-        $crate::macros::push_toml(
+        $crate::macros::push_milf(
             &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+]);
-        $crate::toml_internal!(@toplevel $root [$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+] $($rest)*);
+            &[$(&concat!($("-", $crate::milf_internal!(@path $path),)+)[1..],)+]);
+        $crate::milf_internal!(@toplevel $root [$(&concat!($("-", $crate::milf_internal!(@path $path),)+)[1..],)+] $($rest)*);
     };
 
     // Parse table header `[patch.crates-io]`.
     (@toplevel $root:ident $oldpath:tt [$($($path:tt)-+).+] $($rest:tt)*) => {
-        $crate::macros::insert_toml(
+        $crate::macros::insert_milf(
             &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+],
+            &[$(&concat!($("-", $crate::milf_internal!(@path $path),)+)[1..],)+],
             $crate::Value::Table($crate::value::Table::new()));
-        $crate::toml_internal!(@toplevel $root [$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+] $($rest)*);
+        $crate::milf_internal!(@toplevel $root [$(&concat!($("-", $crate::milf_internal!(@path $path),)+)[1..],)+] $($rest)*);
     };
 
     // Parse datetime from string and insert into table.
     (@topleveldatetime $root:ident [$($path:tt)*] $($($k:tt)-+).+ = ($($datetime:tt)+) $($rest:tt)*) => {
-        $crate::macros::insert_toml(
+        $crate::macros::insert_milf(
             &mut $root,
-            &[$($path)* $(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
+            &[$($path)* $(&concat!($("-", $crate::milf_internal!(@path $k),)+)[1..], )+],
             $crate::Value::Datetime(concat!($(stringify!($datetime)),+).parse().unwrap()));
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($rest)*);
+        $crate::milf_internal!(@toplevel $root [$($path)*] $($rest)*);
     };
 
     // Turn a path segment into a string.
@@ -187,14 +187,14 @@ macro_rules! toml_internal {
     // Construct a Value from an inline table.
     (@value { $($inline:tt)* }) => {{
         let mut table = $crate::Value::Table($crate::value::Table::new());
-        $crate::toml_internal!(@trailingcomma (@table table) $($inline)*);
+        $crate::milf_internal!(@trailingcomma (@table table) $($inline)*);
         table
     }};
 
     // Construct a Value from an inline array.
     (@value [ $($inline:tt)* ]) => {{
         let mut array = $crate::value::Array::new();
-        $crate::toml_internal!(@trailingcomma (@array array) $($inline)*);
+        $crate::milf_internal!(@trailingcomma (@array array) $($inline)*);
         $crate::Value::Array(array)
     }};
 
@@ -234,81 +234,81 @@ macro_rules! toml_internal {
 
     // Parse negative number `key = -value`.
     (@table $root:ident $($($k:tt)-+).+ = - $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@table $root $($($k)-+).+ = (-$v) , $($rest)*);
+        $crate::milf_internal!(@table $root $($($k)-+).+ = (-$v) , $($rest)*);
     };
 
     // Parse positive number `key = +value`.
     (@table $root:ident $($($k:tt)-+).+ = + $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@table $root $($($k)-+).+ = ($v) , $($rest)*);
+        $crate::milf_internal!(@table $root $($($k)-+).+ = ($v) , $($rest)*);
     };
 
     // Parse offset datetime `key = 1979-05-27T00:32:00.999999-07:00`.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
     };
     // Space instead of T.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
     };
 
     // Parse offset datetime `key = 1979-05-27T00:32:00-07:00`.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
     };
     // Space instead of T.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
     };
 
     // Parse local datetime `key = 1979-05-27T00:32:00.999999`.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
     };
     // Space instead of T.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
     };
 
     // Parse offset datetime `key = 1979-05-27T07:32:00Z` and local datetime `key = 1979-05-27T07:32:00`.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec) $($rest)*);
     };
     // Space instead of T.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
     };
 
     // Parse local date `key = 1979-05-27`.
     (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day) $($rest)*);
     };
 
     // Parse local time `key = 00:32:00.999999`.
     (@table $root:ident $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($hr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($hr : $min : $sec . $frac) $($rest)*);
     };
 
     // Parse local time `key = 07:32:00`.
     (@table $root:ident $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($hr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@tabledatetime $root $($($k)-+).+ = ($hr : $min : $sec) $($rest)*);
     };
 
     // Parse any other type, probably string or boolean or number.
     (@table $root:ident $($($k:tt)-+).+ = $v:tt , $($rest:tt)*) => {
-        $crate::macros::insert_toml(
+        $crate::macros::insert_milf(
             &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
-            $crate::toml_internal!(@value $v));
-        $crate::toml_internal!(@table $root $($rest)*);
+            &[$(&concat!($("-", $crate::milf_internal!(@path $k),)+)[1..], )+],
+            $crate::milf_internal!(@value $v));
+        $crate::milf_internal!(@table $root $($rest)*);
     };
 
     // Parse a Datetime from string and continue in @table state.
     (@tabledatetime $root:ident $($($k:tt)-+).+ = ($($datetime:tt)*) $($rest:tt)*) => {
-        $crate::macros::insert_toml(
+        $crate::macros::insert_milf(
             &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
+            &[$(&concat!($("-", $crate::milf_internal!(@path $k),)+)[1..], )+],
             $crate::Value::Datetime(concat!($(stringify!($datetime)),+).parse().unwrap()));
-        $crate::toml_internal!(@table $root $($rest)*);
+        $crate::milf_internal!(@table $root $($rest)*);
     };
 
     // Base case of inline array.
@@ -316,107 +316,107 @@ macro_rules! toml_internal {
 
     // Parse negative number `-value`.
     (@array $root:ident - $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@array $root (-$v) , $($rest)*);
+        $crate::milf_internal!(@array $root (-$v) , $($rest)*);
     };
 
     // Parse positive number `+value`.
     (@array $root:ident + $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@array $root ($v) , $($rest)*);
+        $crate::milf_internal!(@array $root ($v) , $($rest)*);
     };
 
     // Parse offset datetime `1979-05-27T00:32:00.999999-07:00`.
     (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
     };
     // Space instead of T.
     (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
     };
 
     // Parse offset datetime `1979-05-27T00:32:00-07:00`.
     (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
     };
     // Space instead of T.
     (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
     };
 
     // Parse local datetime `1979-05-27T00:32:00.999999`.
     (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
     };
     // Space instead of T.
     (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
     };
 
     // Parse offset datetime `1979-05-27T07:32:00Z` and local datetime `1979-05-27T07:32:00`.
     (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec) $($rest)*);
     };
     // Space instead of T.
     (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
     };
 
     // Parse local date `1979-05-27`.
     (@array $root:ident $yr:tt - $mo:tt - $day:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($yr - $mo - $day) $($rest)*);
     };
 
     // Parse local time `00:32:00.999999`.
     (@array $root:ident $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($hr : $min : $sec . $frac) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($hr : $min : $sec . $frac) $($rest)*);
     };
 
     // Parse local time `07:32:00`.
     (@array $root:ident $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($hr : $min : $sec) $($rest)*);
+        $crate::milf_internal!(@arraydatetime $root ($hr : $min : $sec) $($rest)*);
     };
 
     // Parse any other type, probably string or boolean or number.
     (@array $root:ident $v:tt , $($rest:tt)*) => {
-        $root.push($crate::toml_internal!(@value $v));
-        $crate::toml_internal!(@array $root $($rest)*);
+        $root.push($crate::milf_internal!(@value $v));
+        $crate::milf_internal!(@array $root $($rest)*);
     };
 
     // Parse a Datetime from string and continue in @array state.
     (@arraydatetime $root:ident ($($datetime:tt)*) $($rest:tt)*) => {
         $root.push($crate::Value::Datetime(concat!($(stringify!($datetime)),+).parse().unwrap()));
-        $crate::toml_internal!(@array $root $($rest)*);
+        $crate::milf_internal!(@array $root $($rest)*);
     };
 
     // No trailing comma required if the tokens are empty.
     (@trailingcomma ($($args:tt)*)) => {
-        $crate::toml_internal!($($args)*);
+        $crate::milf_internal!($($args)*);
     };
 
     // Tokens end with a trailing comma, do not append another one.
     (@trailingcomma ($($args:tt)*) ,) => {
-        $crate::toml_internal!($($args)* ,);
+        $crate::milf_internal!($($args)* ,);
     };
 
     // Tokens end with something other than comma, append a trailing comma.
     (@trailingcomma ($($args:tt)*) $last:tt) => {
-        $crate::toml_internal!($($args)* $last ,);
+        $crate::milf_internal!($($args)* $last ,);
     };
 
     // Not yet at the last token.
     (@trailingcomma ($($args:tt)*) $first:tt $($rest:tt)+) => {
-        $crate::toml_internal!(@trailingcomma ($($args)* $first) $($rest)+);
+        $crate::milf_internal!(@trailingcomma ($($args)* $first) $($rest)+);
     };
 }
 
 // Called when parsing a `key = value` pair.
 // Inserts an entry into the table at the given path.
-pub fn insert_toml(root: &mut Value, path: &[&str], value: Value) {
+pub fn insert_milf(root: &mut Value, path: &[&str], value: Value) {
     *traverse(root, path) = value;
 }
 
 // Called when parsing an `[[array header]]`.
 // Pushes an empty table onto the array at the given path.
-pub fn push_toml(root: &mut Value, path: &[&str]) {
+pub fn push_milf(root: &mut Value, path: &[&str]) {
     let target = traverse(root, path);
     if !target.is_array() {
         *target = Value::Array(Array::new());
@@ -434,7 +434,7 @@ fn traverse<'a>(root: &'a mut Value, path: &[&str]) -> &'a mut Value {
         let cur1 = cur;
         let cur2;
 
-        // From the TOML spec:
+        // From the MILF spec:
         //
         // > Each double-bracketed sub-table will belong to the most recently
         // > defined table element above it.
diff --git a/src/map.rs b/src/map.rs
index d130a1d..363433f 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -6,10 +6,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A map of String to toml::Value.
+//! A map of String to milf::Value.
 //!
 //! By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`
-//! feature of toml-rs to use [`LinkedHashMap`] instead.
+//! feature of milf-rs to use [`LinkedHashMap`] instead.
 //!
 //! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
 //! [`LinkedHashMap`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
@@ -28,7 +28,7 @@ use std::collections::{btree_map, BTreeMap};
 #[cfg(feature = "preserve_order")]
 use indexmap::{self, IndexMap};
 
-/// Represents a TOML key/value type.
+/// Represents a MILF key/value type.
 pub struct Map<K, V> {
     map: MapImpl<K, V>,
 }
@@ -504,7 +504,7 @@ impl<'a> IntoIterator for &'a Map<String, Value> {
     }
 }
 
-/// An iterator over a toml::Map's entries.
+/// An iterator over a milf::Map's entries.
 pub struct Iter<'a> {
     iter: IterImpl<'a>,
 }
@@ -529,7 +529,7 @@ impl<'a> IntoIterator for &'a mut Map<String, Value> {
     }
 }
 
-/// A mutable iterator over a toml::Map's entries.
+/// A mutable iterator over a milf::Map's entries.
 pub struct IterMut<'a> {
     iter: IterMutImpl<'a>,
 }
@@ -554,7 +554,7 @@ impl IntoIterator for Map<String, Value> {
     }
 }
 
-/// An owning iterator over a toml::Map's entries.
+/// An owning iterator over a milf::Map's entries.
 pub struct IntoIter {
     iter: IntoIterImpl,
 }
@@ -568,7 +568,7 @@ delegate_iterator!((IntoIter) => (String, Value));
 
 //////////////////////////////////////////////////////////////////////////////
 
-/// An iterator over a toml::Map's keys.
+/// An iterator over a milf::Map's keys.
 pub struct Keys<'a> {
     iter: KeysImpl<'a>,
 }
@@ -582,7 +582,7 @@ delegate_iterator!((Keys<'a>) => &'a String);
 
 //////////////////////////////////////////////////////////////////////////////
 
-/// An iterator over a toml::Map's values.
+/// An iterator over a milf::Map's values.
 pub struct Values<'a> {
     iter: ValuesImpl<'a>,
 }
diff --git a/src/ser.rs b/src/ser.rs
index e115541..dda84fb 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,10 +1,10 @@
-//! Serializing Rust structures into TOML.
+//! Serializing Rust structures into MILF.
 //!
 //! This module contains all the Serde support for serializing Rust structures
-//! into TOML documents (as strings). Note that some top-level functions here
+//! into MILF documents (as strings). Note that some top-level functions here
 //! are also provided at the top of the crate.
 //!
-//! Note that the TOML format has a restriction that if a table itself contains
+//! Note that the MILF format has a restriction that if a table itself contains
 //! tables, all keys with non-table values must be emitted first. This is
 //! typically easy to ensure happens when you're defining a `struct` as you can
 //! reorder the fields manually, but when working with maps (such as `BTreeMap`
@@ -17,7 +17,7 @@
 //! #[derive(Serialize)]
 //! struct Manifest {
 //!     package: Package,
-//!     #[serde(serialize_with = "toml::ser::tables_last")]
+//!     #[serde(serialize_with = "milf::ser::tables_last")]
 //!     dependencies: HashMap<String, Dependency>,
 //! }
 //! # type Package = String;
@@ -34,7 +34,7 @@ use std::rc::Rc;
 use crate::datetime;
 use serde::ser;
 
-/// Serialize the given data structure as a TOML byte vector.
+/// Serialize the given data structure as a MILF byte vector.
 ///
 /// Serialization can fail if `T`'s implementation of `Serialize` decides to
 /// fail, if `T` contains a map with non-string keys, or if `T` attempts to
@@ -46,7 +46,7 @@ where
     to_string(value).map(|e| e.into_bytes())
 }
 
-/// Serialize the given data structure as a String of TOML.
+/// Serialize the given data structure as a String of MILF.
 ///
 /// Serialization can fail if `T`'s implementation of `Serialize` decides to
 /// fail, if `T` contains a map with non-string keys, or if `T` attempts to
@@ -80,8 +80,8 @@ where
 ///         },
 ///     };
 ///
-///     let toml = toml::to_string(&config).unwrap();
-///     println!("{}", toml)
+///     let milf = milf::to_string(&config).unwrap();
+///     println!("{}", milf)
 /// }
 /// ```
 pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error>
@@ -93,7 +93,7 @@ where
     Ok(dst)
 }
 
-/// Serialize the given data structure as a "pretty" String of TOML.
+/// Serialize the given data structure as a "pretty" String of MILF.
 ///
 /// This is identical to `to_string` except the output string has a more
 /// "pretty" output. See `Serializer::pretty` for more details.
@@ -112,11 +112,11 @@ pub enum Error {
     /// Indicates that a Rust type was requested to be serialized but it was not
     /// supported.
     ///
-    /// Currently the TOML format does not support serializing types such as
+    /// Currently the MILF format does not support serializing types such as
     /// enums, tuples and tuple structs.
     UnsupportedType,
 
-    /// The key of all TOML maps must be strings, but serialization was
+    /// The key of all MILF maps must be strings, but serialization was
     /// attempted where the key of a map was not a string.
     KeyNotString,
 
@@ -128,7 +128,7 @@ pub enum Error {
     #[doc(hidden)]
     ArrayMixedType,
 
-    /// All values in a TOML table must be emitted before further tables are
+    /// All values in a MILF table must be emitted before further tables are
     /// emitted. If a value is emitted *after* a table then this error is
     /// generated.
     ValueAfterTable,
@@ -186,10 +186,10 @@ struct Settings {
     string: Option<StringSettings>,
 }
 
-/// Serialization implementation for TOML.
+/// Serialization implementation for MILF.
 ///
-/// This structure implements serialization support for TOML to serialize an
-/// arbitrary type to TOML. Note that the TOML format does not support all
+/// This structure implements serialization support for MILF to serialize an
+/// arbitrary type to MILF. Note that the MILF format does not support all
 /// datatypes in Rust, such as enums, tuples, and tuple structs. These types
 /// will generate an error when serialized.
 ///
@@ -244,7 +244,7 @@ pub enum SerializeTable<'a, 'b> {
 }
 
 impl<'a> Serializer<'a> {
-    /// Creates a new serializer which will emit TOML into the buffer provided.
+    /// Creates a new serializer which will emit MILF into the buffer provided.
     ///
     /// The serializer can then be used to serialize a type after which the data
     /// will be present in `dst`.
@@ -1558,9 +1558,9 @@ enum Category {
 }
 
 /// Convenience function to serialize items in a map in an order valid with
-/// TOML.
+/// MILF.
 ///
-/// TOML carries the restriction that keys in a table must be serialized last if
+/// MILF carries the restriction that keys in a table must be serialized last if
 /// their value is a table itself. This isn't always easy to guarantee, so this
 /// helper can be used like so:
 ///
@@ -1570,7 +1570,7 @@ enum Category {
 /// #[derive(Serialize)]
 /// struct Manifest {
 ///     package: Package,
-///     #[serde(serialize_with = "toml::ser::tables_last")]
+///     #[serde(serialize_with = "milf::ser::tables_last")]
 ///     dependencies: HashMap<String, Dependency>,
 /// }
 /// # type Package = String;
diff --git a/src/spanned.rs b/src/spanned.rs
index 9ee56ae..6c49eb9 100644
--- a/src/spanned.rs
+++ b/src/spanned.rs
@@ -4,16 +4,16 @@ use std::cmp::Ordering;
 use std::fmt;
 use std::hash::{Hash, Hasher};
 
-pub(crate) const NAME: &str = "$__toml_private_Spanned";
-pub(crate) const START: &str = "$__toml_private_start";
-pub(crate) const END: &str = "$__toml_private_end";
-pub(crate) const VALUE: &str = "$__toml_private_value";
+pub(crate) const NAME: &str = "$__milf_private_Spanned";
+pub(crate) const START: &str = "$__milf_private_start";
+pub(crate) const END: &str = "$__milf_private_end";
+pub(crate) const VALUE: &str = "$__milf_private_value";
 
 /// A spanned value, indicating the range at which it is defined in the source.
 ///
 /// ```
 /// use serde_derive::Deserialize;
-/// use toml::Spanned;
+/// use milf::Spanned;
 ///
 /// #[derive(Deserialize)]
 /// struct Value {
@@ -23,7 +23,7 @@ pub(crate) const VALUE: &str = "$__toml_private_value";
 /// fn main() {
 ///     let t = "s = \"value\"\n";
 ///
-///     let u: Value = toml::from_str(t).unwrap();
+///     let u: Value = milf::from_str(t).unwrap();
 ///
 ///     assert_eq!(u.s.start(), 4);
 ///     assert_eq!(u.s.end(), 11);
@@ -122,7 +122,7 @@ where
             type Value = Spanned<T>;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a TOML spanned")
+                formatter.write_str("a MILF spanned")
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Spanned<T>, V::Error>
diff --git a/src/value.rs b/src/value.rs
index 38dfe1f..5bb0c55 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -1,4 +1,4 @@
-//! Definition of a TOML value
+//! Definition of a MILF value
 
 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
@@ -17,36 +17,36 @@ pub use crate::datetime::{Datetime, DatetimeParseError};
 
 pub use crate::map::Map;
 
-/// Representation of a TOML value.
+/// Representation of a MILF value.
 #[derive(PartialEq, Clone, Debug)]
 pub enum Value {
-    /// Represents a TOML string
+    /// Represents a MILF string
     String(String),
-    /// Represents a TOML integer
+    /// Represents a MILF integer
     Integer(i64),
-    /// Represents a TOML float
+    /// Represents a MILF float
     Float(f64),
-    /// Represents a TOML boolean
+    /// Represents a MILF boolean
     Boolean(bool),
-    /// Represents a TOML datetime
+    /// Represents a MILF datetime
     Datetime(Datetime),
-    /// Represents a TOML array
+    /// Represents a MILF array
     Array(Array),
-    /// Represents a TOML table
+    /// Represents a MILF table
     Table(Table),
 }
 
-/// Type representing a TOML array, payload of the `Value::Array` variant
+/// Type representing a MILF array, payload of the `Value::Array` variant
 pub type Array = Vec<Value>;
 
-/// Type representing a TOML table, payload of the `Value::Table` variant.
+/// Type representing a MILF table, payload of the `Value::Table` variant.
 /// By default it is backed by a BTreeMap, enable the `preserve_order` feature
 /// to use a LinkedHashMap instead.
 pub type Table = Map<String, Value>;
 
 impl Value {
-    /// Convert a `T` into `toml::Value` which is an enum that can represent
-    /// any valid TOML data.
+    /// Convert a `T` into `milf::Value` which is an enum that can represent
+    /// any valid MILF data.
     ///
     /// This conversion can fail if `T`'s implementation of `Serialize` decides to
     /// fail, or if `T` contains a map with non-string keys.
@@ -57,14 +57,14 @@ impl Value {
         value.serialize(Serializer)
     }
 
-    /// Interpret a `toml::Value` as an instance of type `T`.
+    /// Interpret a `milf::Value` as an instance of type `T`.
     ///
     /// This conversion can fail if the structure of the `Value` does not match the
     /// structure expected by `T`, for example if `T` is a struct type but the
-    /// `Value` contains something other than a TOML table. It can also fail if the
+    /// `Value` contains something other than a MILF table. It can also fail if the
     /// structure is correct but `T`'s implementation of `Deserialize` decides that
     /// something is wrong with the data, for example required struct fields are
-    /// missing from the TOML map or some number is too big to fit in the expected
+    /// missing from the MILF map or some number is too big to fit in the expected
     /// primitive type.
     pub fn try_into<'de, T>(self) -> Result<T, crate::de::Error>
     where
@@ -73,7 +73,7 @@ impl Value {
         de::Deserialize::deserialize(self)
     }
 
-    /// Index into a TOML array or map. A string index can be used to access a
+    /// Index into a MILF array or map. A string index can be used to access a
     /// value in a map, and a usize index can be used to access an element of an
     /// array.
     ///
@@ -85,7 +85,7 @@ impl Value {
         index.index(self)
     }
 
-    /// Mutably index into a TOML array or map. A string index can be used to
+    /// Mutably index into a MILF array or map. A string index can be used to
     /// access a value in a map, and a usize index can be used to access an
     /// element of an array.
     ///
@@ -151,7 +151,7 @@ impl Value {
 
     /// Extracts the datetime value if it is a datetime.
     ///
-    /// Note that a parsed TOML value will only contain ISO 8601 dates. An
+    /// Note that a parsed MILF value will only contain ISO 8601 dates. An
     /// example date is:
     ///
     /// ```notrust
@@ -302,13 +302,13 @@ impl_into_value!(Boolean: bool);
 impl_into_value!(Datetime: Datetime);
 impl_into_value!(Table: Table);
 
-/// Types that can be used to index a `toml::Value`
+/// Types that can be used to index a `milf::Value`
 ///
 /// Currently this is implemented for `usize` to index arrays and `str` to index
 /// tables.
 ///
 /// This trait is sealed and not intended for implementation outside of the
-/// `toml` crate.
+/// `milf` crate.
 pub trait Index: Sealed {
     #[doc(hidden)]
     fn index<'a>(&self, val: &'a Value) -> Option<&'a Value>;
@@ -453,7 +453,7 @@ impl<'de> de::Deserialize<'de> for Value {
             type Value = Value;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("any valid TOML value")
+                formatter.write_str("any valid MILF value")
             }
 
             fn visit_bool<E>(self, value: bool) -> Result<Value, E> {