libstd: Change all uses of &fn(A)->B over to |A|->B in libstd

Author: pcwalton

src/libstd/ascii.rs

@@ -235,7 +235,7 @@ impl ToStrConsume for ~[Ascii] {
 
 impl IterBytes for Ascii {
     #[inline]
-    fn iter_bytes(&self, _lsb0: bool, f: &fn(buf: &[u8]) -> bool) -> bool {
+    fn iter_bytes(&self, _lsb0: bool, f: |buf: &[u8]| -> bool) -> bool {
         f([self.to_byte()])
     }
 }

src/libstd/at_vec.rs

@@ -43,7 +43,7 @@ pub fn capacity<T>(v: @[T]) -> uint {
  *             onto the vector being constructed.
  */
 #[inline]
-pub fn build<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> @[A] {
+pub fn build<A>(size: Option<uint>, builder: |push: |v: A||) -> @[A] {
     let mut vec = @[];
     unsafe { raw::reserve(&mut vec, size.unwrap_or(4)); }
     builder(|x| unsafe { raw::push(&mut vec, x) });
@@ -68,7 +68,7 @@ pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
 
 
 /// Apply a function to each element of a vector and return the results
-pub fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] {
+pub fn map<T, U>(v: &[T], f: |x: &T| -> U) -> @[U] {
     do build(Some(v.len())) |push| {
         for elem in v.iter() {
             push(f(elem));
@@ -82,7 +82,7 @@ pub fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value returned by the function `op`.
  */
-pub fn from_fn<T>(n_elts: uint, op: &fn(uint) -> T) -> @[T] {
+pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> @[T] {
     do build(Some(n_elts)) |push| {
         let mut i: uint = 0u;
         while i < n_elts { push(op(i)); i += 1u; }

src/libstd/bool.rs

@@ -58,7 +58,7 @@ use num::FromPrimitive;
 /// }
 /// ```
 #[inline]
-pub fn all_values(blk: &fn(v: bool)) {
+pub fn all_values(blk: |v: bool|) {
     blk(true);
     blk(false);
 }

src/libstd/c_str.rs

@@ -117,7 +117,7 @@ impl CString {
     /// # Failure
     ///
     /// Fails if the CString is null.
-    pub fn with_ref<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    pub fn with_ref<T>(&self, f: |*libc::c_char| -> T) -> T {
         if self.buf.is_null() { fail!("CString is null!"); }
         f(self.buf)
     }
@@ -127,7 +127,7 @@ impl CString {
     /// # Failure
     ///
     /// Fails if the CString is null.
-    pub fn with_mut_ref<T>(&mut self, f: &fn(*mut libc::c_char) -> T) -> T {
+    pub fn with_mut_ref<T>(&mut self, f: |*mut libc::c_char| -> T) -> T {
         if self.buf.is_null() { fail!("CString is null!"); }
         f(unsafe { cast::transmute_mut_unsafe(self.buf) })
     }
@@ -223,13 +223,13 @@ pub trait ToCStr {
     ///
     /// Raises the `null_byte` condition if the receiver has an interior null.
     #[inline]
-    fn with_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    fn with_c_str<T>(&self, f: |*libc::c_char| -> T) -> T {
         self.to_c_str().with_ref(f)
     }
 
     /// Unsafe variant of `with_c_str()` that doesn't check for nulls.
     #[inline]
-    unsafe fn with_c_str_unchecked<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    unsafe fn with_c_str_unchecked<T>(&self, f: |*libc::c_char| -> T) -> T {
         self.to_c_str_unchecked().with_ref(f)
     }
 }
@@ -246,12 +246,12 @@ impl<'self> ToCStr for &'self str {
     }
 
     #[inline]
-    fn with_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    fn with_c_str<T>(&self, f: |*libc::c_char| -> T) -> T {
         self.as_bytes().with_c_str(f)
     }
 
     #[inline]
-    unsafe fn with_c_str_unchecked<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    unsafe fn with_c_str_unchecked<T>(&self, f: |*libc::c_char| -> T) -> T {
         self.as_bytes().with_c_str_unchecked(f)
     }
 }
@@ -282,17 +282,17 @@ impl<'self> ToCStr for &'self [u8] {
         }
     }
 
-    fn with_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    fn with_c_str<T>(&self, f: |*libc::c_char| -> T) -> T {
         unsafe { with_c_str(*self, true, f) }
     }
 
-    unsafe fn with_c_str_unchecked<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+    unsafe fn with_c_str_unchecked<T>(&self, f: |*libc::c_char| -> T) -> T {
         with_c_str(*self, false, f)
     }
 }
 
 // Unsafe function that handles possibly copying the &[u8] into a stack array.
-unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: &fn(*libc::c_char) -> T) -> T {
+unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: |*libc::c_char| -> T) -> T {
     if v.len() < BUF_LEN {
         let mut buf: [u8, .. BUF_LEN] = intrinsics::uninit();
         vec::bytes::copy_memory(buf, v, v.len());
@@ -357,7 +357,7 @@ impl<'self> Iterator<libc::c_char> for CStringIterator<'self> {
 /// is found, and the number of strings found is returned.
 pub unsafe fn from_c_multistring(buf: *libc::c_char,
                                  count: Option<uint>,
-                                 f: &fn(&CString)) -> uint {
+                                 f: |&CString|) -> uint {
 
     let mut curr_ptr: uint = buf as uint;
     let mut ctr = 0;

src/libstd/cell.rs

@@ -71,12 +71,12 @@ impl<T> Cell<T> {
     }
 
     /// Calls a closure with a reference to the value.
-    pub fn with_ref<R>(&self, op: &fn(v: &T) -> R) -> R {
+    pub fn with_ref<R>(&self, op: |v: &T| -> R) -> R {
         do self.with_mut_ref |ptr| { op(ptr) }
     }
 
     /// Calls a closure with a mutable reference to the value.
-    pub fn with_mut_ref<R>(&self, op: &fn(v: &mut T) -> R) -> R {
+    pub fn with_mut_ref<R>(&self, op: |v: &mut T| -> R) -> R {
         let mut v = Some(self.take());
         do (|| {
             op(v.get_mut_ref())

src/libstd/char.rs

@@ -241,7 +241,7 @@ static N_COUNT: uint = (V_COUNT * T_COUNT);
 static S_COUNT: uint = (L_COUNT * N_COUNT);
 
 // Decompose a precomposed Hangul syllable
-fn decompose_hangul(s: char, f: &fn(char)) {
+fn decompose_hangul(s: char, f: |char|) {
     let si = s as uint - S_BASE;
 
     let li = si / N_COUNT;
@@ -259,7 +259,7 @@ fn decompose_hangul(s: char, f: &fn(char)) {
 }
 
 /// Returns the canonical decompostion of a character
-pub fn decompose_canonical(c: char, f: &fn(char)) {
+pub fn decompose_canonical(c: char, f: |char|) {
     if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
         decompose::canonical(c, f);
     } else {
@@ -268,7 +268,7 @@ pub fn decompose_canonical(c: char, f: &fn(char)) {
 }
 
 /// Returns the compatibility decompostion of a character
-pub fn decompose_compatible(c: char, f: &fn(char)) {
+pub fn decompose_compatible(c: char, f: |char|) {
     if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
         decompose::compatibility(c, f);
     } else {
@@ -285,7 +285,7 @@ pub fn decompose_compatible(c: char, f: &fn(char)) {
 /// - chars in [0x100,0xffff] get 4-digit escapes: `\\uNNNN`
 /// - chars above 0x10000 get 8-digit escapes: `\\UNNNNNNNN`
 ///
-pub fn escape_unicode(c: char, f: &fn(char)) {
+pub fn escape_unicode(c: char, f: |char|) {
     // avoid calling str::to_str_radix because we don't really need to allocate
     // here.
     f('\\');
@@ -316,7 +316,7 @@ pub fn escape_unicode(c: char, f: &fn(char)) {
 /// - Any other chars in the range [0x20,0x7e] are not escaped.
 /// - Any other chars are given hex unicode escapes; see `escape_unicode`.
 ///
-pub fn escape_default(c: char, f: &fn(char)) {
+pub fn escape_default(c: char, f: |char|) {
     match c {
         '\t' => { f('\\'); f('t'); }
         '\r' => { f('\\'); f('r'); }
@@ -367,8 +367,8 @@ pub trait Char {
     fn is_digit_radix(&self, radix: uint) -> bool;
     fn to_digit(&self, radix: uint) -> Option<uint>;
     fn from_digit(num: uint, radix: uint) -> Option<char>;
-    fn escape_unicode(&self, f: &fn(char));
-    fn escape_default(&self, f: &fn(char));
+    fn escape_unicode(&self, f: |char|);
+    fn escape_default(&self, f: |char|);
     fn len_utf8_bytes(&self) -> uint;
 
     /// Encodes this character as utf-8 into the provided byte-buffer. The
@@ -403,9 +403,9 @@ impl Char for char {
 
     fn from_digit(num: uint, radix: uint) -> Option<char> { from_digit(num, radix) }
 
-    fn escape_unicode(&self, f: &fn(char)) { escape_unicode(*self, f) }
+    fn escape_unicode(&self, f: |char|) { escape_unicode(*self, f) }
 
-    fn escape_default(&self, f: &fn(char)) { escape_default(*self, f) }
+    fn escape_default(&self, f: |char|) { escape_default(*self, f) }
 
     fn len_utf8_bytes(&self) -> uint { len_utf8_bytes(*self) }
 

src/libstd/cleanup.rs

@@ -30,7 +30,8 @@ struct AnnihilateStats {
 }
 
 unsafe fn each_live_alloc(read_next_before: bool,
-                          f: &fn(box: *mut raw::Box<()>, uniq: bool) -> bool) -> bool {
+                          f: |box: *mut raw::Box<()>, uniq: bool| -> bool)
+                          -> bool {
     //! Walks the internal list of allocations
 
     use managed;

src/libstd/condition.rs

@@ -133,7 +133,7 @@ impl<T, U> Condition<T, U> {
 
     /// Performs the same functionality as `raise`, except that when no handler
     /// is found the `default` argument is called instead of failing the task.
-    pub fn raise_default(&self, t: T, default: &fn() -> U) -> U {
+    pub fn raise_default(&self, t: T, default: || -> U) -> U {
         match local_data::pop(self.key) {
             None => {
                 debug!("Condition.raise: found no handler");
@@ -145,7 +145,7 @@ impl<T, U> Condition<T, U> {
                     None => {}
                     Some(hp) => local_data::set(self.key, hp)
                 }
-                let handle : &fn(T) -> U = unsafe {
+                let handle : |T| -> U = unsafe {
                     ::cast::transmute(handler.handle)
                 };
                 let u = handle(t);

src/libstd/either.rs

@@ -38,7 +38,7 @@ impl<L, R> Either<L, R> {
     /// `value` is `Right(R)` then `f_right` is applied to its contents, and the
     /// result is returned.
     #[inline]
-    pub fn either<T>(&self, f_left: &fn(&L) -> T, f_right: &fn(&R) -> T) -> T {
+    pub fn either<T>(&self, f_left: |&L| -> T, f_right: |&R| -> T) -> T {
         match *self {
             Left(ref l) => f_left(l),
             Right(ref r) => f_right(r)

src/libstd/fmt/mod.rs

@@ -931,8 +931,10 @@ impl<'self> Formatter<'self> {
         }
     }
 
-    fn with_padding(&mut self, padding: uint,
-                    default: parse::Alignment, f: &fn(&mut Formatter)) {
+    fn with_padding(&mut self,
+                    padding: uint,
+                    default: parse::Alignment,
+                    f: |&mut Formatter|) {
         let align = match self.align {
             parse::AlignUnknown => default,
             parse::AlignLeft | parse::AlignRight => self.align

src/libstd/hash.rs

@@ -408,7 +408,7 @@ mod tests {
     // Hash just the bytes of the slice, without length prefix
     struct Bytes<'self>(&'self [u8]);
     impl<'self> IterBytes for Bytes<'self> {
-        fn iter_bytes(&self, _lsb0: bool, f: &fn(&[u8]) -> bool) -> bool {
+        fn iter_bytes(&self, _lsb0: bool, f: |&[u8]| -> bool) -> bool {
             f(**self)
         }
     }

src/libstd/hashmap.rs

@@ -80,8 +80,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
     }
 
     #[inline]
-    fn bucket_sequence(&self, hash: uint,
-                       op: &fn(uint) -> bool) -> bool {
+    fn bucket_sequence(&self, hash: uint, op: |uint| -> bool) -> bool {
         let start_idx = self.to_bucket(hash);
         let len_buckets = self.buckets.len();
         let mut idx = start_idx;
@@ -360,8 +359,14 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
 
     /// Modify and return the value corresponding to the key in the map, or
     /// insert and return a new value if it doesn't exist.
-    pub fn mangle<'a,A>(&'a mut self, k: K, a: A, not_found: &fn(&K, A) -> V,
-                        found: &fn(&K, &mut V, A)) -> &'a mut V {
+    pub fn mangle<'a,
+                  A>(
+                  &'a mut self,
+                  k: K,
+                  a: A,
+                  not_found: |&K, A| -> V,
+                  found: |&K, &mut V, A|)
+                  -> &'a mut V {
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
             // that we do not resize if this call to insert is
@@ -395,16 +400,20 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
 
     /// Return the value corresponding to the key in the map, or create,
     /// insert, and return a new value if it doesn't exist.
-    pub fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V)
+    pub fn find_or_insert_with<'a>(&'a mut self, k: K, f: |&K| -> V)
                                -> &'a mut V {
         self.mangle(k, (), |k,_a| f(k), |_k,_v,_a| ())
     }
 
     /// Insert a key-value pair into the map if the key is not already present.
     /// Otherwise, modify the existing value for the key.
     /// Returns the new or modified value for the key.
-    pub fn insert_or_update_with<'a>(&'a mut self, k: K, v: V,
-                                     f: &fn(&K, &mut V)) -> &'a mut V {
+    pub fn insert_or_update_with<'a>(
+                                 &'a mut self,
+                                 k: K,
+                                 v: V,
+                                 f: |&K, &mut V|)
+                                 -> &'a mut V {
         self.mangle(k, v, |_k,a| a, |k,v,_a| f(k,v))
     }
 
@@ -446,12 +455,12 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     }
 
     /// Visit all keys
-    pub fn each_key(&self, blk: &fn(k: &K) -> bool) -> bool {
+    pub fn each_key(&self, blk: |k: &K| -> bool) -> bool {
         self.iter().advance(|(k, _)| blk(k))
     }
 
     /// Visit all values
-    pub fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) -> bool {
+    pub fn each_value<'a>(&'a self, blk: |v: &'a V| -> bool) -> bool {
         self.iter().advance(|(_, v)| blk(v))
     }
 

src/libstd/io/extensions.rs

@@ -54,8 +54,7 @@ impl<'self, R: Reader> Iterator<u8> for ByteIterator<R> {
     }
 }
 
-pub fn u64_to_le_bytes<T>(n: u64, size: uint,
-                          f: &fn(v: &[u8]) -> T) -> T {
+pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
@@ -88,8 +87,7 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint,
     }
 }
 
-pub fn u64_to_be_bytes<T>(n: u64, size: uint,
-                           f: &fn(v: &[u8]) -> T) -> T {
+pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),

src/libstd/io/fs.rs

@@ -75,7 +75,7 @@ pub struct File {
     priv last_nread: int,
 }
 
-fn io_raise<T>(f: &fn(io: &mut IoFactory) -> Result<T, IoError>) -> Option<T> {
+fn io_raise<T>(f: |io: &mut IoFactory| -> Result<T, IoError>) -> Option<T> {
     do with_local_io |io| {
         match f(io) {
             Ok(t) => Some(t),
@@ -499,7 +499,7 @@ pub fn rmdir(path: &Path) {
 ///     use std::io::fs;
 ///
 ///     // one possible implementation of fs::walk_dir only visiting files
-///     fn visit_dirs(dir: &Path, cb: &fn(&Path)) {
+///     fn visit_dirs(dir: &Path, cb: |&Path|) {
 ///         if dir.is_dir() {
 ///             let contents = fs::readdir(dir).unwrap();
 ///             for entry in contents.iter() {

src/libstd/io/mem.rs

@@ -240,7 +240,7 @@ impl<'self> Buffer for BufReader<'self> {
 
 ///Calls a function with a MemWriter and returns
 ///the writer's stored vector.
-pub fn with_mem_writer(writeFn:&fn(&mut MemWriter)) -> ~[u8] {
+pub fn with_mem_writer(writeFn: |&mut MemWriter|) -> ~[u8] {
     let mut writer = MemWriter::new();
     writeFn(&mut writer);
     writer.inner()

src/libstd/io/mod.rs

@@ -394,7 +394,7 @@ condition! {
 
 /// Helper for wrapper calls where you want to
 /// ignore any io_errors that might be raised
-pub fn ignore_io_error<T>(cb: &fn() -> T) -> T {
+pub fn ignore_io_error<T>(cb: || -> T) -> T {
     do io_error::cond.trap(|_| {
         // just swallow the error.. downstream users
         // who can make a decision based on a None result
@@ -407,7 +407,7 @@ pub fn ignore_io_error<T>(cb: &fn() -> T) -> T {
 /// Helper for catching an I/O error and wrapping it in a Result object. The
 /// return result will be the last I/O error that happened or the result of the
 /// closure if no error occurred.
-pub fn result<T>(cb: &fn() -> T) -> Result<T, IoError> {
+pub fn result<T>(cb: || -> T) -> Result<T, IoError> {
     let mut err = None;
     let ret = io_error::cond.trap(|e| {
         if err.is_none() {