Remove serde implementation from TimelyStack (#645)

Removes the serde implementation for TimelyStack. I have very low
confidence it is correct, and it is inefficient, too. Nobody should rely
on it.

Signed-off-by: Moritz Hoffmann <[email protected]>

Author: antiguru

container/src/columnation.rs

@@ -263,76 +263,6 @@ impl<T: Columnation> PushInto<&&T> for TimelyStack<T> {
     }
 }
 
-mod serde {
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-    use crate::columnation::{Columnation, TimelyStack};
-
-    impl<T: Columnation + Serialize> Serialize for TimelyStack<T> {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            use serde::ser::SerializeSeq;
-            let mut seq = serializer.serialize_seq(Some(self.local.len()))?;
-            for element in &self[..] {
-                seq.serialize_element(element)?;
-            }
-            seq.end()
-        }
-    }
-
-    impl<'a, T: Columnation + Deserialize<'a>> Deserialize<'a> for TimelyStack<T> {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'a>,
-        {
-            use serde::de::{SeqAccess, Visitor};
-            use std::fmt;
-            use std::marker::PhantomData;
-            struct TimelyStackVisitor<T> {
-                marker: PhantomData<T>,
-            }
-
-            impl<'de, T: Columnation> Visitor<'de> for TimelyStackVisitor<T>
-            where
-                T: Deserialize<'de>,
-            {
-                type Value = TimelyStack<T>;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("a sequence")
-                }
-
-                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                where
-                    A: SeqAccess<'de>,
-                {
-                    let local = Vec::with_capacity(
-                        seq.size_hint()
-                            .unwrap_or(crate::buffer::default_capacity::<T>()),
-                    );
-                    let mut stack = TimelyStack {
-                        local,
-                        inner: T::InnerRegion::default(),
-                    };
-
-                    while let Some(value) = seq.next_element()? {
-                        stack.copy(&value);
-                    }
-
-                    Ok(stack)
-                }
-            }
-
-            let visitor = TimelyStackVisitor {
-                marker: PhantomData,
-            };
-            deserializer.deserialize_seq(visitor)
-        }
-    }
-}
-
 mod container {
     use std::ops::Deref;
     use crate::{Container, SizableContainer};