diff --git a/src/json/builder.rs b/src/json/builder.rs
index 08a82713..65b14154 100644
--- a/src/json/builder.rs
+++ b/src/json/builder.rs
@@ -13,31 +13,31 @@ use std::str::StrAllocating;
 
 use json::value::{ToJson, Value};
 
-pub struct ListBuilder {
-    list: Vec<Value>,
+pub struct ArrayBuilder {
+    array: Vec<Value>,
 }
 
-impl ListBuilder {
-    pub fn new() -> ListBuilder {
-        ListBuilder { list: Vec::new() }
+impl ArrayBuilder {
+    pub fn new() -> ArrayBuilder {
+        ArrayBuilder { array: Vec::new() }
     }
 
     pub fn unwrap(self) -> Value {
-        Value::List(self.list)
+        Value::Array(self.array)
     }
 
-    pub fn push<T: ToJson>(self, value: T) -> ListBuilder {
+    pub fn push<T: ToJson>(self, value: T) -> ArrayBuilder {
         let mut builder = self;
-        builder.list.push(value.to_json());
+        builder.array.push(value.to_json());
         builder
     }
 
-    pub fn push_list(self, f: |ListBuilder| -> ListBuilder) -> ListBuilder {
-        let builder = ListBuilder::new();
+    pub fn push_array(self, f: |ArrayBuilder| -> ArrayBuilder) -> ArrayBuilder {
+        let builder = ArrayBuilder::new();
         self.push(f(builder).unwrap())
     }
 
-    pub fn push_object(self, f: |ObjectBuilder| -> ObjectBuilder) -> ListBuilder {
+    pub fn push_object(self, f: |ObjectBuilder| -> ObjectBuilder) -> ArrayBuilder {
         let builder = ObjectBuilder::new();
         self.push(f(builder).unwrap())
     }
@@ -62,8 +62,8 @@ impl ObjectBuilder {
         builder
     }
 
-    pub fn insert_list<S: StrAllocating>(self, key: S, f: |ListBuilder| -> ListBuilder) -> ObjectBuilder {
-        let builder = ListBuilder::new();
+    pub fn insert_array<S: StrAllocating>(self, key: S, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
+        let builder = ArrayBuilder::new();
         self.insert(key.into_string(), f(builder).unwrap())
     }
 
@@ -78,26 +78,26 @@ mod tests {
     use std::collections::TreeMap;
 
     use json::value::Value;
-    use super::{ListBuilder, ObjectBuilder};
+    use super::{ArrayBuilder, ObjectBuilder};
 
     #[test]
-    fn test_list_builder() {
-        let value = ListBuilder::new().unwrap();
-        assert_eq!(value, Value::List(Vec::new()));
+    fn test_array_builder() {
+        let value = ArrayBuilder::new().unwrap();
+        assert_eq!(value, Value::Array(Vec::new()));
 
-        let value = ListBuilder::new()
+        let value = ArrayBuilder::new()
             .push(1i)
             .push(2i)
             .push(3i)
             .unwrap();
-        assert_eq!(value, Value::List(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
+        assert_eq!(value, Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
 
-        let value = ListBuilder::new()
-            .push_list(|bld| bld.push(1i).push(2i).push(3i))
+        let value = ArrayBuilder::new()
+            .push_array(|bld| bld.push(1i).push(2i).push(3i))
             .unwrap();
-        assert_eq!(value, Value::List(vec!(Value::List(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
+        assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
 
-        let value = ListBuilder::new()
+        let value = ArrayBuilder::new()
             .push_object(|bld|
                 bld
                     .insert("a".to_string(), 1i)
@@ -107,7 +107,7 @@ mod tests {
         let mut map = TreeMap::new();
         map.insert("a".to_string(), Value::Integer(1));
         map.insert("b".to_string(), Value::Integer(2));
-        assert_eq!(value, Value::List(vec!(Value::Object(map))));
+        assert_eq!(value, Value::Array(vec!(Value::Object(map))));
     }
 
     #[test]
diff --git a/src/json/mod.rs b/src/json/mod.rs
index e9c8cef7..4861390c 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -292,7 +292,7 @@ fn main() {
 
 */
 
-pub use self::builder::{ListBuilder, ObjectBuilder};
+pub use self::builder::{ArrayBuilder, ObjectBuilder};
 pub use self::de::{
     Parser,
     from_str,
diff --git a/src/json/value.rs b/src/json/value.rs
index 7f37f8c8..9f43d58b 100644
--- a/src/json/value.rs
+++ b/src/json/value.rs
@@ -21,7 +21,7 @@ pub enum Value {
     Integer(i64),
     Floating(f64),
     String(string::String),
-    List(Vec<Value>),
+    Array(Vec<Value>),
     Object(TreeMap<string::String, Value>),
 }
 
@@ -107,16 +107,16 @@ impl Value {
         }
     }
 
-    /// Returns true if the Json value is a List. Returns false otherwise.
-    pub fn is_list<'a>(&'a self) -> bool {
-        self.as_list().is_some()
+    /// Returns true if the Json value is a Array. Returns false otherwise.
+    pub fn is_array<'a>(&'a self) -> bool {
+        self.as_array().is_some()
     }
 
-    /// If the Json value is a List, returns the associated vector.
+    /// If the Json value is a Array, returns the associated vector.
     /// Returns None otherwise.
-    pub fn as_list<'a>(&'a self) -> Option<&'a Vec<Value>> {
+    pub fn as_array<'a>(&'a self) -> Option<&'a Vec<Value>> {
         match *self {
-            Value::List(ref list) => Some(list),
+            Value::Array(ref array) => Some(array),
             _ => None
         }
     }
@@ -243,7 +243,7 @@ impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Value {
             Value::String(ref v) => {
                 v.serialize(s)
             }
-            Value::List(ref v) => {
+            Value::Array(ref v) => {
                 v.serialize(s)
             }
             Value::Object(ref v) => {
@@ -277,8 +277,8 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
             Token::Option(false) => Ok(Value::Null),
             Token::Option(true) => de::Deserialize::deserialize(d),
             Token::TupleStart(_) | Token::SeqStart(_) => {
-                let list = try!(de::Deserialize::deserialize_token(d, token));
-                Ok(Value::List(list))
+                let array = try!(de::Deserialize::deserialize_token(d, token));
+                Ok(Value::Array(array))
             }
             Token::StructStart(_, _) | Token::MapStart(_) => {
                 let object = try!(de::Deserialize::deserialize_token(d, token));
@@ -288,7 +288,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
                 let token = Token::SeqStart(len);
                 let fields: Vec<Value> = try!(de::Deserialize::deserialize_token(d, token));
                 let mut object = TreeMap::new();
-                object.insert(name.to_string(), Value::List(fields));
+                object.insert(name.to_string(), Value::Array(fields));
                 Ok(Value::Object(object))
             }
             Token::End => {
@@ -303,7 +303,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
 
 enum State {
     Value(Value),
-    List(vec::MoveItems<Value>),
+    Array(vec::MoveItems<Value>),
     Object(tree_map::MoveEntries<string::String, Value>),
     End,
 }
@@ -333,9 +333,9 @@ impl Iterator<Result<Token, Error>> for Deserializer {
                         Value::Integer(x) => Token::I64(x),
                         Value::Floating(x) => Token::F64(x),
                         Value::String(x) => Token::String(x),
-                        Value::List(x) => {
+                        Value::Array(x) => {
                             let len = x.len();
-                            self.stack.push(State::List(x.into_iter()));
+                            self.stack.push(State::Array(x.into_iter()));
                             Token::SeqStart(len)
                         }
                         Value::Object(x) => {
@@ -347,10 +347,10 @@ impl Iterator<Result<Token, Error>> for Deserializer {
 
                     return Some(Ok(token));
                 }
-                Some(State::List(mut iter)) => {
+                Some(State::Array(mut iter)) => {
                     match iter.next() {
                         Some(value) => {
-                            self.stack.push(State::List(iter));
+                            self.stack.push(State::Array(iter));
                             self.stack.push(State::Value(value));
                             // loop around.
                         }
@@ -441,11 +441,11 @@ impl de::Deserializer<Error> for Deserializer {
                 };
 
                 let (variant, fields) = match iter.next() {
-                    Some((variant, Value::List(fields))) => (variant, fields),
+                    Some((variant, Value::Array(fields))) => (variant, fields),
                     Some((key, value)) => {
                         return Err(
                             Error::ExpectedError(
-                                "List".to_string(),
+                                "Array".to_string(),
                                 format!("{} => {}", key, value)
                             )
                         );
@@ -608,12 +608,12 @@ macro_rules! impl_to_json_tuple {
 
                 let ($(ref $name,)*) = *self;
 
-                let mut list = Vec::with_capacity(len);
+                let mut array = Vec::with_capacity(len);
                 $(
-                    list.push($name.to_json());
+                    array.push($name.to_json());
                  )*
 
-                Value::List(list)
+                Value::Array(array)
             }
         }
         peel_to_json_tuple!($($name,)*)
@@ -624,7 +624,7 @@ impl_to_json_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
 impl<A:ToJson> ToJson for Vec<A> {
     fn to_json(&self) -> Value {
-        Value::List(self.iter().map(|elt| elt.to_json()).collect())
+        Value::Array(self.iter().map(|elt| elt.to_json()).collect())
     }
 }