Merge pull request #173 from vinipsmaker/encode-result

Add trait implementation for `Result<T, E>`

Author: alexcrichton

src/json.rs

@@ -3206,6 +3206,15 @@ mod tests {
         assert_eq!(value, Frog("Henry".to_string(), 349));
     }
 
+    #[test]
+    fn test_decode_result() {
+        let value: Result<i32, i8> = Ok(4);
+        let json_value = super::encode(&value).unwrap();
+        assert_eq!(json_value, "{\"variant\":\"Ok\",\"fields\":[4]}");
+        let decoded_value: Result<i32, i8> = super::decode(&json_value).unwrap();
+        assert_eq!(decoded_value, Ok(4));
+    }
+
     #[test]
     fn test_decode_map() {
         let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\

src/serialize.rs

@@ -1214,6 +1214,53 @@ impl<T:Decodable> Decodable for Option<T> {
     }
 }
 
+impl<T:Encodable, E:Encodable> Encodable for Result<T, E> {
+    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+        s.emit_enum("Result", |s| {
+            match *self {
+                Ok(ref v) => {
+                    s.emit_enum_variant("Ok", 0, 1, |s| {
+                        try!(s.emit_enum_variant_arg(0, |s| {
+                            v.encode(s)
+                        }));
+                        Ok(())
+                    })
+                }
+                Err(ref v) => {
+                    s.emit_enum_variant("Err", 1, 1, |s| {
+                        try!(s.emit_enum_variant_arg(0, |s| {
+                            v.encode(s)
+                        }));
+                        Ok(())
+                    })
+                }
+            }
+        })
+    }
+}
+
+impl<T: Decodable, E: Decodable> Decodable for Result<T, E> {
+    fn decode<D: Decoder>(d: &mut D) -> Result<Result<T, E>, D::Error> {
+        d.read_enum("Result", |d| {
+            d.read_enum_variant(&["Ok", "Err"], |d, idx| {
+                match idx {
+                    0 => {
+                        d.read_enum_variant_arg(0, |d| {
+                            T::decode(d)
+                        }).map(|v| Ok(v))
+                    }
+                    1 => {
+                        d.read_enum_variant_arg(0, |d| {
+                            E::decode(d)
+                        }).map(|v| Err(v))
+                    }
+                    _ => panic!("Internal error"),
+                }
+            })
+        })
+    }
+}
+
 impl<T> Encodable for PhantomData<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_nil()