-/*!
-
-Defines the `Ord` and `Eq` comparison traits.
-
-This module defines both `Ord` and `Eq` traits which are used by the compiler
-to implement comparison operators.
-Rust programs may implement `Ord` to overload the `<`, `<=`, `>`, and `>=` operators,
-and may implement `Eq` to overload the `==` and `!=` operators.
-
-For example, to define a type with a customized definition for the Eq operators,
-you could do the following:
-
-```rust
-// Our type.
-struct SketchyNum {
- num : int
-}
-
-// Our implementation of `Eq` to support `==` and `!=`.
-impl Eq for SketchyNum {
- // Our custom eq allows numbers which are near eachother to be equal! :D
- fn eq(&self, other: &SketchyNum) -> bool {
- (self.num - other.num).abs() < 5
- }
-}
-
-// Now these binary operators will work when applied!
-assert!(SketchyNum {num: 37} == SketchyNum {num: 34});
-assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
-```
-
-*/
-
-/**
-* Trait for values that can be compared for equality and inequality.
-*
-* This trait allows partial equality, where types can be unordered instead of strictly equal or
-* unequal. For example, with the built-in floating-point types `a == b` and `a != b` will both
-* evaluate to false if either `a` or `b` is NaN (cf. IEEE 754-2008 section 5.11).
-*
-* Eq only requires the `eq` method to be implemented; `ne` is its negation by default.
-*
-* Eventually, this will be implemented by default for types that implement `TotalEq`.
-*/
+//! Defines the `Ord` and `Eq` comparison traits.
+//!
+//! This module defines both `Ord` and `Eq` traits which are used by the
+//! compiler to implement comparison operators. Rust programs may implement
+//!`Ord` to overload the `<`, `<=`, `>`, and `>=` operators, and may implement
+//! `Eq` to overload the `==` and `!=` operators.
+//!
+//! For example, to define a type with a customized definition for the Eq
+//! operators, you could do the following:
+//!
+//! ```rust
+//! // Our type.
+//! struct SketchyNum {
+//! num : int
+//! }
+//!
+//! // Our implementation of `Eq` to support `==` and `!=`.
+//! impl Eq for SketchyNum {
+//! // Our custom eq allows numbers which are near eachother to be equal! :D
+//! fn eq(&self, other: &SketchyNum) -> bool {
+//! (self.num - other.num).abs() < 5
+//! }
+//! }
+//!
+//! // Now these binary operators will work when applied!
+//! assert!(SketchyNum {num: 37} == SketchyNum {num: 34});
+//! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
+//! ```
+
+/// Trait for values that can be compared for equality and inequality.
+///
+/// This trait allows partial equality, where types can be unordered instead of
+/// strictly equal or unequal. For example, with the built-in floating-point
+/// types `a == b` and `a != b` will both evaluate to false if either `a` or
+/// `b` is NaN (cf. IEEE 754-2008 section 5.11).
+///
+/// Eq only requires the `eq` method to be implemented; `ne` is its negation by
+/// default.
+///
+/// Eventually, this will be implemented by default for types that implement
+/// `TotalEq`.