From 823c7eee6a040862abb5a5309693030394200e62 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Mon, 21 Apr 2014 23:25:18 -0700 Subject: Fix other bugs with new closure borrowing This fixes various issues throughout the standard distribution and tests. --- src/libstd/io/net/ip.rs | 8 ++++---- src/libstd/iter.rs | 8 ++++---- src/libstd/option.rs | 4 ++-- src/libstd/result.rs | 8 ++++---- src/libstd/slice.rs | 11 ++++++----- src/libstd/unstable/finally.rs | 6 +++--- 6 files changed, 23 insertions(+), 22 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index f61b282767f..7621a7ec4cd 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -107,9 +107,9 @@ impl<'a> Parser<'a> { } // Return result of first successful parser - fn read_or(&mut self, parsers: &[|&mut Parser| -> Option]) + fn read_or(&mut self, parsers: &mut [|&mut Parser| -> Option]) -> Option { - for pf in parsers.iter() { + for pf in parsers.mut_iter() { match self.read_atomically(|p: &mut Parser| (*pf)(p)) { Some(r) => return Some(r), None => {} @@ -305,7 +305,7 @@ impl<'a> Parser<'a> { fn read_ip_addr(&mut self) -> Option { let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr(); let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr(); - self.read_or([ipv4_addr, ipv6_addr]) + self.read_or(&mut [ipv4_addr, ipv6_addr]) } fn read_socket_addr(&mut self) -> Option { @@ -318,7 +318,7 @@ impl<'a> Parser<'a> { p.read_seq_3::(open_br, ip_addr, clos_br) .map(|t| match t { (_, ip, _) => ip }) }; - p.read_or([ipv4_p, ipv6_p]) + p.read_or(&mut [ipv4_p, ipv6_p]) }; let colon = |p: &mut Parser| p.read_given_char(':'); let port = |p: &mut Parser| p.read_number(10, 5, 0x10000).map(|n| n as u16); diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs index ec5d7390164..d895331752f 100644 --- a/src/libstd/iter.rs +++ b/src/libstd/iter.rs @@ -1241,7 +1241,7 @@ pub struct Map<'a, A, B, T> { impl<'a, A, B, T> Map<'a, A, B, T> { #[inline] - fn do_map(&self, elt: Option) -> Option { + fn do_map(&mut self, elt: Option) -> Option { match elt { Some(a) => Some((self.f)(a)), _ => None @@ -1824,7 +1824,7 @@ pub struct Inspect<'a, A, T> { impl<'a, A, T> Inspect<'a, A, T> { #[inline] - fn do_inspect(&self, elt: Option) -> Option { + fn do_inspect(&mut self, elt: Option) -> Option { match elt { Some(ref a) => (self.f)(a), None => () @@ -2910,7 +2910,7 @@ mod tests { let xs = [1, 2, 3, 4, 5]; // test .map and .inspect that don't implement Clone - let it = xs.iter().inspect(|_| {}); + let mut it = xs.iter().inspect(|_| {}); assert_eq!(xs.len(), it.indexable()); for (i, elt) in xs.iter().enumerate() { assert_eq!(Some(elt), it.idx(i)); @@ -2922,7 +2922,7 @@ mod tests { fn test_random_access_map() { let xs = [1, 2, 3, 4, 5]; - let it = xs.iter().map(|x| *x); + let mut it = xs.iter().map(|x| *x); assert_eq!(xs.len(), it.indexable()); for (i, elt) in xs.iter().enumerate() { assert_eq!(Some(*elt), it.idx(i)); diff --git a/src/libstd/option.rs b/src/libstd/option.rs index 557e2043381..efbb1abacfa 100644 --- a/src/libstd/option.rs +++ b/src/libstd/option.rs @@ -873,9 +873,9 @@ mod tests { assert_eq!(v, None); // test that it does not take more elements than it needs - let functions = [|| Some(()), || None, || fail!()]; + let mut functions = [|| Some(()), || None, || fail!()]; - let v: Option<~[()]> = collect(functions.iter().map(|f| (*f)())); + let v: Option<~[()]> = collect(functions.mut_iter().map(|f| (*f)())); assert_eq!(v, None); } diff --git a/src/libstd/result.rs b/src/libstd/result.rs index 7080da266f6..058548eb151 100644 --- a/src/libstd/result.rs +++ b/src/libstd/result.rs @@ -695,9 +695,9 @@ mod tests { assert_eq!(v, Err(2)); // test that it does not take more elements than it needs - let functions = [|| Ok(()), || Err(1), || fail!()]; + let mut functions = [|| Ok(()), || Err(1), || fail!()]; - let v: Result<~[()], int> = collect(functions.iter().map(|f| (*f)())); + let v: Result<~[()], int> = collect(functions.mut_iter().map(|f| (*f)())); assert_eq!(v, Err(1)); } @@ -715,9 +715,9 @@ mod tests { Err(2)); // test that it does not take more elements than it needs - let functions = [|| Ok(()), || Err(1), || fail!()]; + let mut functions = [|| Ok(()), || Err(1), || fail!()]; - assert_eq!(fold_(functions.iter() + assert_eq!(fold_(functions.mut_iter() .map(|f| (*f)())), Err(1)); } diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs index 309ea8623e5..f9f919edaaa 100644 --- a/src/libstd/slice.rs +++ b/src/libstd/slice.rs @@ -212,8 +212,7 @@ impl<'a, T> Iterator<&'a [T]> for RevSplits<'a, T> { return Some(self.v); } - let pred = &mut self.pred; - match self.v.iter().rposition(|x| (*pred)(x)) { + match self.v.iter().rposition(|x| (self.pred)(x)) { None => { self.finished = true; Some(self.v) @@ -2132,7 +2131,8 @@ impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { fn next(&mut self) -> Option<&'a mut [T]> { if self.finished { return None; } - match self.v.iter().position(|x| (self.pred)(x)) { + let pred = &mut self.pred; + match self.v.iter().position(|x| (*pred)(x)) { None => { self.finished = true; let tmp = mem::replace(&mut self.v, &mut []); @@ -2167,7 +2167,8 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> { fn next_back(&mut self) -> Option<&'a mut [T]> { if self.finished { return None; } - match self.v.iter().rposition(|x| (self.pred)(x)) { + let pred = &mut self.pred; + match self.v.iter().rposition(|x| (*pred)(x)) { None => { self.finished = true; let tmp = mem::replace(&mut self.v, &mut []); @@ -3340,7 +3341,7 @@ mod tests { assert_eq!(v.chunks(6).collect::<~[&[int]]>(), ~[&[1i,2,3,4,5]]); assert_eq!(v.chunks(2).rev().collect::<~[&[int]]>(), ~[&[5i], &[3,4], &[1,2]]); - let it = v.chunks(2); + let mut it = v.chunks(2); assert_eq!(it.indexable(), 3); assert_eq!(it.idx(0).unwrap(), &[1,2]); assert_eq!(it.idx(1).unwrap(), &[3,4]); diff --git a/src/libstd/unstable/finally.rs b/src/libstd/unstable/finally.rs index 96e52a4818e..3d00c0ac74a 100644 --- a/src/libstd/unstable/finally.rs +++ b/src/libstd/unstable/finally.rs @@ -145,7 +145,7 @@ fn test_fail() { #[test] fn test_retval() { - let closure: || -> int = || 10; + let mut closure: || -> int = || 10; let i = closure.finally(|| { }); assert_eq!(i, 10); } @@ -154,6 +154,6 @@ fn test_retval() { fn test_compact() { fn do_some_fallible_work() {} fn but_always_run_this_function() { } - do_some_fallible_work.finally( - but_always_run_this_function); + let mut f = do_some_fallible_work; + f.finally(but_always_run_this_function); } -- cgit 1.4.1-3-g733a5