From c43426e35ba89fe52cd48b70d240f5014937f71f Mon Sep 17 00:00:00 2001 From: Kevin Cantu Date: Wed, 12 Sep 2012 22:09:55 -0700 Subject: [PATCH] CamelCase and demode json.rs and deque.rs --- src/libstd/deque.rs | 165 ++++++++++++++++++++++++-------------------- src/libstd/json.rs | 9 ++- 2 files changed, 96 insertions(+), 78 deletions(-) diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 920b969eea9cf..4c4dcdeabe9e0 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -1,7 +1,11 @@ //! A deque. Untested as of yet. Likely buggy +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; +#[forbid(non_camel_case_types)]; use option::{Some, None}; use dvec::DVec; +use core::cmp::{Eq}; trait Deque { fn size() -> uint; @@ -24,8 +28,9 @@ fn create() -> Deque { * Grow is only called on full elts, so nelts is also len(elts), unlike * elsewhere. */ - fn grow(nelts: uint, lo: uint, -elts: ~[mut Cell]) -> - ~[mut Cell] { + fn grow(nelts: uint, lo: uint, +elts: ~[mut Cell]) + -> ~[mut Cell] { + let elts = move elts; assert (nelts == vec::len(elts)); let mut rv = ~[mut]; @@ -40,8 +45,8 @@ fn create() -> Deque { move rv } - fn get(elts: DVec>, i: uint) -> T { - match elts.get_elt(i) { Some(t) => t, _ => fail } + fn get(elts: &DVec>, i: uint) -> T { + match (*elts).get_elt(i) { Some(t) => t, _ => fail } } type Repr = {mut nelts: uint, @@ -79,7 +84,7 @@ fn create() -> Deque { * that we don't keep anyone's refcount up unexpectedly. */ fn pop_front() -> T { - let t: T = get(self.elts, self.lo); + let t: T = get(&self.elts, self.lo); self.elts.set_elt(self.lo, None); self.lo = (self.lo + 1u) % self.elts.len(); self.nelts -= 1u; @@ -89,16 +94,16 @@ fn create() -> Deque { if self.hi == 0u { self.hi = self.elts.len() - 1u; } else { self.hi -= 1u; } - let t: T = get(self.elts, self.hi); + let t: T = get(&self.elts, self.hi); self.elts.set_elt(self.hi, None); self.nelts -= 1u; return t; } - fn peek_front() -> T { return get(self.elts, self.lo); } - fn peek_back() -> T { return get(self.elts, self.hi - 1u); } + fn peek_front() -> T { return get(&self.elts, self.lo); } + fn peek_back() -> T { return get(&self.elts, self.hi - 1u); } fn get(i: int) -> T { let idx = (self.lo + (i as uint)) % self.elts.len(); - return get(self.elts, idx); + return get(&self.elts, idx); } } @@ -160,7 +165,13 @@ mod tests { assert (d.get(3) == 4); } - fn test_boxes(a: @int, b: @int, c: @int, d: @int) { + #[test] + fn test_boxes() { + let a: @int = @5; + let b: @int = @72; + let c: @int = @64; + let d: @int = @175; + let deq: deque::Deque<@int> = deque::create::<@int>(); assert (deq.size() == 0u); deq.add_front(a); @@ -190,11 +201,7 @@ mod tests { assert (deq.get(3) == d); } - type EqFn = fn@(T, T) -> bool; - - fn test_parameterized( - e: EqFn, a: T, b: T, c: T, d: T) { - + fn test_parameterized(+a: T, +b: T, +c: T, +d: T) { let deq: deque::Deque = deque::create::(); assert (deq.size() == 0u); deq.add_front(a); @@ -203,12 +210,12 @@ mod tests { assert (deq.size() == 3u); deq.add_back(d); assert (deq.size() == 4u); - assert (e(deq.peek_front(), b)); - assert (e(deq.peek_back(), d)); - assert (e(deq.pop_front(), b)); - assert (e(deq.pop_back(), d)); - assert (e(deq.pop_back(), c)); - assert (e(deq.pop_back(), a)); + assert deq.peek_front() == b; + assert deq.peek_back() == d; + assert deq.pop_front() == b; + assert deq.pop_back() == d; + assert deq.pop_back() == c; + assert deq.pop_back() == a; assert (deq.size() == 0u); deq.add_back(c); assert (deq.size() == 1u); @@ -218,10 +225,10 @@ mod tests { assert (deq.size() == 3u); deq.add_front(a); assert (deq.size() == 4u); - assert (e(deq.get(0), a)); - assert (e(deq.get(1), b)); - assert (e(deq.get(2), c)); - assert (e(deq.get(3), d)); + assert deq.get(0) == a; + assert deq.get(1) == b; + assert deq.get(2) == c; + assert deq.get(3) == d; } enum Taggy { One(int), Two(int, int), Three(int, int, int), } @@ -232,78 +239,86 @@ mod tests { type RecCy = {x: int, y: int, t: Taggy}; - #[test] - fn test() { - fn inteq(&&a: int, &&b: int) -> bool { return a == b; } - fn intboxeq(&&a: @int, &&b: @int) -> bool { return a == b; } - fn taggyeq(a: Taggy, b: Taggy) -> bool { - match a { - One(a1) => match b { + impl Taggy : Eq { + pure fn eq(other: Taggy) -> bool { + match self { + One(a1) => match other { One(b1) => return a1 == b1, _ => return false }, - Two(a1, a2) => match b { + Two(a1, a2) => match other { Two(b1, b2) => return a1 == b1 && a2 == b2, _ => return false }, - Three(a1, a2, a3) => match b { + Three(a1, a2, a3) => match other { Three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3, _ => return false } } } - fn taggypareq(a: Taggypar, b: Taggypar) -> bool { - match a { - Onepar::(a1) => match b { - Onepar::(b1) => return a1 == b1, - _ => return false - }, - Twopar::(a1, a2) => match b { - Twopar::(b1, b2) => return a1 == b1 && a2 == b2, - _ => return false - }, - Threepar::(a1, a2, a3) => match b { - Threepar::(b1, b2, b3) => { - return a1 == b1 && a2 == b2 && a3 == b3 - } - _ => return false - } - } + pure fn ne(other: Taggy) -> bool { !self.eq(other) } + } + + impl Taggypar : Eq { + //let eq4: EqFn> = |x,y| taggypareq::(x, y); + pure fn eq(other: Taggypar) -> bool { + match self { + Onepar::(a1) => match other { + Onepar::(b1) => return a1 == b1, + _ => return false + }, + Twopar::(a1, a2) => match other { + Twopar::(b1, b2) => return a1 == b1 && a2 == b2, + _ => return false + }, + Threepar::(a1, a2, a3) => match other { + Threepar::(b1, b2, b3) => { + return a1 == b1 && a2 == b2 && a3 == b3 + } + _ => return false + } + } } - fn reccyeq(a: RecCy, b: RecCy) -> bool { - return a.x == b.x && a.y == b.y && taggyeq(a.t, b.t); + pure fn ne(other: Taggypar) -> bool { !self.eq(other) } + } + + impl RecCy : Eq { + pure fn eq(other: RecCy) -> bool { + return self.x == other.x && self.y == other.y && self.t == other.t; } - debug!("*** test boxes"); - test_boxes(@5, @72, @64, @175); - debug!("*** end test boxes"); - debug!("test parameterized: int"); - let eq1: EqFn = inteq; - test_parameterized::(eq1, 5, 72, 64, 175); - debug!("*** test parameterized: @int"); - let eq2: EqFn<@int> = intboxeq; - test_parameterized::<@int>(eq2, @5, @72, @64, @175); - debug!("*** end test parameterized @int"); - debug!("test parameterized: taggy"); - let eq3: EqFn = taggyeq; - test_parameterized::(eq3, One(1), Two(1, 2), Three(1, 2, 3), + pure fn ne(other: RecCy) -> bool { !self.eq(other) } + } + + #[test] + fn test_param_int() { + test_parameterized::(5, 72, 64, 175); + } + + #[test] + fn test_param_at_int() { + test_parameterized::<@int>(@5, @72, @64, @175); + } + + #[test] + fn test_param_taggy() { + test_parameterized::(One(1), Two(1, 2), Three(1, 2, 3), Two(17, 42)); + } - debug!("*** test parameterized: taggypar"); - let eq4: EqFn> = |x,y| taggypareq::(x, y); - test_parameterized::>(eq4, Onepar::(1), + #[test] + fn test_param_taggypar() { + test_parameterized::>(Onepar::(1), Twopar::(1, 2), Threepar::(1, 2, 3), Twopar::(17, 42)); - debug!("*** end test parameterized: taggypar::"); + } - debug!("*** test parameterized: reccy"); + #[test] + fn test_param_reccy() { let reccy1: RecCy = {x: 1, y: 2, t: One(1)}; let reccy2: RecCy = {x: 345, y: 2, t: Two(1, 2)}; let reccy3: RecCy = {x: 1, y: 777, t: Three(1, 2, 3)}; let reccy4: RecCy = {x: 19, y: 252, t: Two(17, 42)}; - let eq5: EqFn = reccyeq; - test_parameterized::(eq5, reccy1, reccy2, reccy3, reccy4); - debug!("*** end test parameterized: reccy"); - debug!("*** done"); + test_parameterized::(reccy1, reccy2, reccy3, reccy4); } } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 182c1d61bc050..8db0e0bfc10ee 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1,5 +1,8 @@ // Rust JSON serialization library // Copyright (c) 2011 Google Inc. +#[forbid(deprecated_mode)]; +#[forbid(deprecated_pattern)]; +#[forbid(non_camel_case_types)]; //! json serialization @@ -174,7 +177,7 @@ fn to_writer_pretty(wr: io::Writer, j: Json, indent: uint) { } } -fn escape_str(s: ~str) -> ~str { +fn escape_str(s: &str) -> ~str { let mut escaped = ~"\""; do str::chars_iter(s) |c| { match c { @@ -574,7 +577,7 @@ fn from_reader(rdr: io::Reader) -> Result { } /// Deserializes a json value from a string -fn from_str(s: ~str) -> Result { +fn from_str(s: &str) -> Result { io::with_str_reader(s, from_reader) } @@ -828,7 +831,7 @@ impl Error: to_str::ToStr { #[cfg(test)] mod tests { - fn mk_dict(items: ~[(~str, Json)]) -> Json { + fn mk_dict(items: &[(~str, Json)]) -> Json { let d = map::str_hash(); do vec::iter(items) |item| {