From 7b47f1e891de9d5d6e62875cb7129eb2652626f7 Mon Sep 17 00:00:00 2001
From: bluss <bluss@users.noreply.github.com>
Date: Fri, 18 Sep 2015 01:00:55 +0200
Subject: [PATCH] Use no public fields for CapacityError

---
 src/array_string.rs |  6 +++---
 src/lib.rs          | 10 +++++++---
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/array_string.rs b/src/array_string.rs
index d6b6089..154b74c 100644
--- a/src/array_string.rs
+++ b/src/array_string.rs
@@ -70,7 +70,7 @@ impl<A: Array<Item=u8>> ArrayString<A> {
     /// let overflow = string.push('c');
     ///
     /// assert_eq!(&string[..], "ab");
-    /// assert_eq!(overflow.err().map(|e| e.element), Some('c'));
+    /// assert_eq!(overflow.unwrap_err().element(), 'c');
     /// ```
     pub fn push(&mut self, c: char) -> Result<(), CapacityError<char>> {
         use std::fmt::Write;
@@ -93,8 +93,8 @@ impl<A: Array<Item=u8>> ArrayString<A> {
     /// let overflow2 = string.push_str("ef");
     ///
     /// assert_eq!(&string[..], "ad");
-    /// assert_eq!(overflow1.err().map(|e| e.element), Some("bc"));
-    /// assert_eq!(overflow2.err().map(|e| e.element), Some("ef"));
+    /// assert_eq!(overflow1.unwrap_err().element(), "bc");
+    /// assert_eq!(overflow2.unwrap_err().element(), "ef");
     /// ```
     pub fn push_str<'a>(&mut self, s: &'a str) -> Result<(), CapacityError<&'a str>> {
         use std::io::Write;
diff --git a/src/lib.rs b/src/lib.rs
index de84109..148861f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -36,19 +36,23 @@ unsafe fn new_array<A: Array>() -> A {
     mem::uninitialized()
 }
 
+/// Error value indicating insufficient capacity
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub struct CapacityError<T> {
-    _unused: (),
-    pub element: T,
+    element: T,
 }
 
 impl<T> CapacityError<T> {
     fn new(element: T) -> CapacityError<T> {
         CapacityError {
-            _unused: (),
             element: element,
         }
     }
+
+    /// Extract the overflowing element
+    pub fn element(self) -> T {
+        self.element
+    }
 }
 
 /// A vector with a fixed capacity.