Use Either rather than using custom enum type

Author: puddingpy

Cargo.toml

@@ -20,6 +20,7 @@ serde_json = "1.0"
 time = { version = "0.3.7", features = ["serde-well-known", "formatting", "parsing"] }
 jsonwebtoken = { version = "8", default-features = false }
 yaup = "0.2.0"
+either = { version = "1.8.0" , features = ["serde"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 futures = "0.3"

src/search.rs

@@ -1,38 +1,27 @@
 use crate::{errors::Error, indexes::Index};
 use serde::{de::DeserializeOwned, Deserialize, Serialize, Serializer};
-use serde::ser::{SerializeSeq};
 use serde_json::{Map, Value};
 use std::collections::HashMap;
+use either::Either;
 
 #[derive(Deserialize, Debug, Eq, PartialEq)]
 pub struct MatchRange {
     pub start: usize,
     pub length: usize,
 }
 
-#[derive(Debug, Eq, PartialEq , Clone)]
-pub enum Filter<'a> {
-    String(&'a str),
-    Array(Vec<&'a str>)
+#[derive(Serialize , Debug, Eq, PartialEq , Clone)]
+#[serde(transparent)]
+pub struct Filter<'a>{
+    #[serde(with = "either::serde_untagged")]
+    inner: Either<&'a str , Vec<&'a str>>
 }
 
-impl<'a> Serialize for Filter<'a> {
-    fn serialize<S>(&self , serializer: S) -> Result<S::Ok , S::Error>
-    where
-        S: Serializer
-    {
-        match self {
-            Filter::String(s) => serializer.serialize_str(s),
-            Filter::Array(s) => {
-                let mut seq = serializer.serialize_seq(Some(s.len()))?;
-
-                for item in s {
-                    seq.serialize_element(item)?;
-                }
-
-                seq.end()
-            },
-        } 
+impl<'a> Filter<'a> {
+    pub fn new(inner: Either<&'a str , Vec<&'a str>>) -> Filter {
+        Filter {
+            inner
+        }
     }
 }
 
@@ -311,11 +300,11 @@ impl<'a> SearchQuery<'a> {
         self
     }
     pub fn with_filter<'b>(&'b mut self, filter: &'a str) -> &'b mut SearchQuery<'a> {
-        self.filter = Some(Filter::String(filter));
+        self.filter = Some(Filter::new(Either::Left(filter)));
         self
     }
     pub fn with_array_filter<'b>(&'b mut self , filter: Vec<&'a str>) -> &'b mut SearchQuery<'a> {
-        self.filter = Some(Filter::Array(filter));
+        self.filter = Some(Filter::new(Either::Right(filter)));
         self
     }
     pub fn with_facets<'b>(