Update to latest rust nightly.

- rustc 0.13.0-nightly (126db549b 2014-12-15 00:07:35 +0000)

src/reader.rs

@@ -70,85 +70,88 @@ impl<'a, R: Reader+Buffer> Decoder<IoError> for DecoderReader<'a, R> {
         }
         Ok(String::from_utf8(vector).unwrap())
     }
-    fn read_enum<T>(&mut self, _: &str,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_enum_variant<T>(&mut self, _: &[&str],
-    f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) -> IoResult<T> {
-        let id = try!(self.read_uint());
-        f(self, id)
-    }
-    fn read_enum_variant_arg<T>(&mut self, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_enum_struct_variant<T>(&mut self, names: &[&str],
-    f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) -> IoResult<T> {
-        self.read_enum_variant(names, f)
-    }
-    fn read_enum_struct_variant_field<T>(&mut self, _: &str, f_idx: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        self.read_enum_variant_arg(f_idx, f)
-    }
-    fn read_struct<T>(&mut self, _: &str, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_struct_field<T>(&mut self, _: &str, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_tuple<T>(&mut self, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) ->
-    IoResult<T> {
-        f(self)
-    }
-    fn read_tuple_arg<T>(&mut self, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_tuple_struct<T>(&mut self, _: &str, len: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) ->
-    IoResult<T> {
-        self.read_tuple(len, f)
-    }
-    fn read_tuple_struct_arg<T>(&mut self, a_idx: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        self.read_tuple_arg(a_idx, f)
-    }
-    fn read_option<T>(&mut self,
-    f: |&mut DecoderReader<'a, R>, bool| -> IoResult<T>) ->
-    IoResult<T> {
-        match try!(self.reader.read_u8()) {
-            1 => f(self, true),
-            _ => f(self, false)
+    fn read_enum<T, F>(&mut self, name: &str, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
+            let id = try!(self.read_uint());
+            f(self, id)
+        }
+    fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
+            self.read_enum_variant(names, f)
+        }
+    fn read_enum_struct_variant_field<T, F>(&mut self,
+                                            _: &str,
+                                            f_idx: uint,
+                                            f: F)
+        -> IoResult<T> where
+            F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+                self.read_enum_variant_arg(f_idx, f)
+            }
+    fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_struct_field<T, F>(&mut self,
+                               f_name: &str,
+                               f_idx: uint,
+                               f: F)
+        -> IoResult<T> where
+            F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+                f(self)
+            }
+    fn read_tuple<T, F>(&mut self, len: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            self.read_tuple(len, f)
+        }
+    fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            self.read_tuple_arg(a_idx, f)
+        }
+    fn read_option<T, F>(&mut self, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>, bool) -> IoResult<T> {
+            match try!(self.reader.read_u8()) {
+                1 => f(self, true),
+                _ => f(self, false)
+            }
+        }
+    fn read_seq<T, F>(&mut self, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
+            let len = try!(self.read_uint());
+            f(self, len)
+        }
+    fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_map<T, F>(&mut self, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
+            let len = try!(self.read_uint());
+            f(self, len)
+        }
+    fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
+        }
+    fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> IoResult<T> where
+        F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
+            f(self)
         }
-    }
-    fn read_seq<T>(&mut self,
-    f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) ->
-    IoResult<T> {
-        let len = try!(self.read_uint());
-        f(self, len)
-    }
-    fn read_seq_elt<T>(&mut self, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_map<T>(&mut self,
-    f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) ->
-    IoResult<T> {
-        let len = try!(self.read_uint());
-        f(self, len)
-    }
-    fn read_map_elt_key<T>(&mut self, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
-    fn read_map_elt_val<T>(&mut self, _: uint,
-    f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
-        f(self)
-    }
     fn error(&mut self, err: &str) -> IoError {
         IoError {
             kind: OtherIoError,

src/writer.rs

@@ -61,84 +61,92 @@ impl<'a, W: Writer> Encoder<IoError> for EncoderWriter<'a, W> {
         try!(self.emit_uint(v.len()));
         self.writer.write_str(v)
     }
-    fn emit_enum(&mut self, _: &str,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_enum_variant(&mut self,
-    _: &str, v_id: uint, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        try!(self.emit_uint(v_id));
-        f(self)
-    }
-    fn emit_enum_variant_arg(&mut self, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_enum_struct_variant(&mut self, _: &str, _: uint,
-    _: uint, f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_enum_struct_variant_field(&mut self, _: &str,
-    _: uint, f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_struct(&mut self, _: &str, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_struct_field(&mut self, _: &str, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_tuple(&mut self, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_tuple_arg(&mut self, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_tuple_struct(&mut self, _: &str, len: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        self.emit_tuple(len, f)
-    }
-    fn emit_tuple_struct_arg(&mut self, f_idx: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        self.emit_tuple_arg(f_idx, f)
-    }
-    fn emit_option(&mut self,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
+    fn emit_enum<F>(&mut self, name: &str, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_enum_variant<F>(&mut self, v_name: &str,
+                            v_id: uint,
+                            len: uint,
+                            f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            try!(self.emit_uint(v_id));
+            f(self)
+        }
+    fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
+                                   v_id: uint,
+                                   len: uint,
+                                   f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_enum_struct_variant_field<F>(&mut self,
+                                         f_name: &str,
+                                         f_idx: uint,
+                                         f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_tuple<F>(&mut self, len: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            self.emit_tuple(len, f)
+        }
+    fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            self.emit_tuple_arg(f_idx, f)
+        }
+    fn emit_option<F>(&mut self, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
     fn emit_option_none(&mut self) -> EwResult {
         self.writer.write_u8(0)
     }
-    fn emit_option_some(&mut self,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        try!(self.writer.write_u8(1));
-        f(self)
-    }
-    fn emit_seq(&mut self, len: uint,
-    f: |this: &mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        try!(self.emit_uint(len));
-        f(self)
-    }
-    fn emit_seq_elt(&mut self, _: uint,
-    f: |this: &mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_map(&mut self, len: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        try!(self.emit_uint(len));
-        f(self)
-    }
-    fn emit_map_elt_key(&mut self, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
-    fn emit_map_elt_val(&mut self, _: uint,
-    f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult {
-        f(self)
-    }
+    fn emit_option_some<F>(&mut self, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            try!(self.writer.write_u8(1));
+            f(self)
+        }
+    fn emit_seq<F>(&mut self, len: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            try!(self.emit_uint(len));
+            f(self)
+        }
+    fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_map<F>(&mut self, len: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            try!(self.emit_uint(len));
+            f(self)
+        }
+    fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EwResult where
+        F: FnMut(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
+    fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> EwResult where
+        F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
+            f(self)
+        }
 }