---

yaml
---
r: 152229
b: refs/heads/try2
c: a413d00
h: refs/heads/master
i:
  152227: 48ae73a
v: v3

Author: Jorge Aparicio

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7fa5baa7cae5ba84cdd50cfebc729ea82c0a2f39
+refs/heads/try2: a413d005a77d294f6e7b173b898684d56224b19f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/README.md

@@ -5,37 +5,26 @@ Source layout:
 | Path                | Description                                               |
 | ------------------- | --------------------------------------------------------- |
 | `librustc/`         | The self-hosted compiler                                  |
-| `liballoc/`         | Rust's core allocation library                            |
-| `libcore/`          | The Rust core library                                     |
-| `libdebug/`         | Debugging utilities                                       |
 | `libstd/`           | The standard library (imported and linked by default)     |
+| `libextra/`         | The "extras" library (slightly more peripheral code)      |
 | `libgreen/`         | The M:N runtime library                                   |
 | `libnative/`        | The 1:1 runtime library                                   |
 | `libsyntax/`        | The Rust parser and pretty-printer                        |
+| `libcollections/`   | A collection of useful data structures and containers     |
+| `libnum/`           | Extended number support library (complex, rational, etc)  |
 | `libtest/`          | Rust's test-runner code                                   |
 | ------------------- | --------------------------------------------------------- |
 | `libarena/`         | The arena (a fast but limited) memory allocator           |
-| `libbacktrace/`     | The libbacktrace library                                  |
-| `libcollections/`   | A collection of useful data structures and containers     |
 | `libflate/`         | Simple compression library                                |
-| `libfmt_macros/`    | Macro support for format strings                          |
 | `libfourcc/`        | Data format identifier library                            |
 | `libgetopts/`       | Get command-line-options library                          |
 | `libglob/`          | Unix glob patterns library                                |
-| `libgraphviz/`      | Generating files for Graphviz                             |
-| `libhexfloat/`      | Hexadecimal floating-point literals                       |
-| `liblibc/`          | Bindings for the C standard library                       |
-| `liblog/`           | Utilities for program-wide and customizable logging       |
-| `libnum/`           | Extended number support library (complex, rational, etc)  |
-| `librand/`          | Random numbers and distributions                          |
 | `libregex/`         | Regular expressions                                       |
-| `libregex_macros/`  | The regex! syntax extension                               |
 | `libsemver/`        | Rust's semantic versioning library                        |
 | `libserialize/`     | Encode-Decode types library                               |
 | `libsync/`          | Concurrency mechanisms and primitives                     |
 | `libterm/`          | ANSI color library for terminals                          |
 | `libtime/`          | Time operations library                                   |
-| `liburl/`           | URL handling lirary                                       |
 | `libuuid/`          | UUID's handling code                                      |
 | ------------------- | --------------------------------------------------------- |
 | `rt/`               | The runtime system                                        |

branches/try2/src/doc/intro.md

@@ -18,7 +18,7 @@ and its implications on a task that programmers usually find very difficult: con
 
 Ownership is central to Rust,
 and is the feature from which many of Rust's powerful capabilities are derived.
-"Ownership" refers to which parts of your code are allowed to read,
+"Ownership" refers to which parts of your code are allowed read,
 write, and ultimately release, memory.
 Let's start by looking at some C++ code:
 

branches/try2/src/libserialize/json.rs

@@ -2227,6 +2227,10 @@ impl<A:ToJson,B:ToJson,C:ToJson> ToJson for (A, B, C) {
     }
 }
 
+impl<'a, A:ToJson> ToJson for &'a [A] {
+    fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
+}
+
 impl<A:ToJson> ToJson for ~[A] {
     fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
 }
@@ -3334,6 +3338,56 @@ mod tests {
         assert!(stack.get(1) == Key("foo"));
     }
 
+    #[test]
+    fn test_to_json() {
+        use collections::{HashMap,TreeMap};
+        use super::ToJson;
+
+        let list2 = List(vec!(Number(1.0_f64), Number(2.0_f64)));
+        let list3 = List(vec!(Number(1.0f64), Number(2.0f64), Number(3.0f64)));
+        let object = {
+            let mut tree_map = TreeMap::new();
+            tree_map.insert("a".to_string(), Number(1.0_f64));
+            tree_map.insert("b".to_string(), Number(2.0_f64));
+            Object(box tree_map)
+        };
+
+        assert_eq!(list2.to_json(), list2);
+        assert_eq!(object.to_json(), object);
+        assert_eq!(3_i.to_json(), Number(3.0_f64));
+        assert_eq!(4_i8.to_json(), Number(4.0_f64));
+        assert_eq!(5_i16.to_json(), Number(5.0_f64));
+        assert_eq!(6_i32.to_json(), Number(6.0_f64));
+        assert_eq!(7_i64.to_json(), Number(7.0_f64));
+        assert_eq!(8_u.to_json(), Number(8.0_f64));
+        assert_eq!(9_u8.to_json(), Number(9.0_f64));
+        assert_eq!(10_u16.to_json(), Number(10.0_f64));
+        assert_eq!(11_u32.to_json(), Number(11.0_f64));
+        assert_eq!(12_u64.to_json(), Number(12.0_f64));
+        assert_eq!(13.0_f32.to_json(), Number(13.0_f64));
+        assert_eq!(14.0_f64.to_json(), Number(14.0_f64));
+        assert_eq!(().to_json(), Null);
+        assert_eq!(true.to_json(), Boolean(true));
+        assert_eq!(false.to_json(), Boolean(false));
+        assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
+        assert_eq!((1, 2).to_json(), list2);
+        assert_eq!((1, 2, 3).to_json(), list3);
+        assert_eq!([1, 2].to_json(), list2);
+        assert_eq!((&[1, 2, 3]).to_json(), list3);
+        assert_eq!((~[1, 2]).to_json(), list2);
+        assert_eq!(vec!(1, 2, 3).to_json(), list3);
+        let mut tree_map = TreeMap::new();
+        tree_map.insert("a".to_string(), 1);
+        tree_map.insert("b".to_string(), 2);
+        assert_eq!(tree_map.to_json(), object);
+        let mut hash_map = HashMap::new();
+        hash_map.insert("a".to_string(), 1);
+        hash_map.insert("b".to_string(), 2);
+        assert_eq!(hash_map.to_json(), object);
+        assert_eq!(Some(15).to_json(), Number(15 as f64));
+        assert_eq!(None::<int>.to_json(), Null);
+    }
+
     #[bench]
     fn bench_streaming_small(b: &mut Bencher) {
         b.iter( || {