Change:
I've been told that parameter names are not part of the API, so this might not matter at all (except to pedantic people like me): I've found 17 functions with the name : Most of them use as parameter name: Some functions, however, use as argument name: Others are using : Wouldn't it make sense to call all of them ? Does anyone care about such things? If yes, we could play the same game with and probably with other common functions.
Parameter names are not part of the API because arguments in Rust are always only positional, which means that changing the name is never a breaking change. This means that we both don't care to change it nor to keep it as is ^_^ I think this is for T-libs/T-docs to decide.
I encourage you to post a PR which unifies the names. They appear in the documentation, so this is essentially a documentation improvement, and those are generally well accepted.
Done:

Discussion:
VecDeque::with_capacity(INITIAL_CAPACITY) } <del> /// Creates an empty `VecDeque` with space for at least `n` elements. </del> <ins> /// Creates an empty `VecDeque` with space for at least `capacity` elements. </ins> /// /// # Examples ///

/// let vector: VecDeque<u32> = VecDeque::with_capacity(10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] <del> pub fn with_capacity(n: usize) -> VecDeque<T> { </del> <ins> pub fn with_capacity(capacity: usize) -> VecDeque<T> { </ins> // +1 since the ringbuffer always leaves one space empty <del> let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); assert!(cap > n, "capacity overflow"); </del> <ins> let cap = cmp::max(capacity + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); assert!(cap > capacity, "capacity overflow"); </ins> VecDeque { tail: 0,

GrowableBitSet { bit_set: BitSet::new_empty(0) } } <del> pub fn with_capacity(bits: usize) -> GrowableBitSet<T> { GrowableBitSet { bit_set: BitSet::new_empty(bits) } </del> <ins> pub fn with_capacity(capacity: usize) -> GrowableBitSet<T> { GrowableBitSet { bit_set: BitSet::new_empty(capacity) } </ins> } /// Returns `true` if the set has changed.

/// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] <del> pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> { </del> <ins> pub fn with_capacity(capacity: usize, inner: R) -> BufReader<R> { </ins> unsafe { <del> let mut buffer = Vec::with_capacity(cap); buffer.set_len(cap); </del> <ins> let mut buffer = Vec::with_capacity(capacity); buffer.set_len(capacity); </ins> inner.initializer().initialize(&mut buffer); BufReader { inner,

/// let mut buffer = BufWriter::with_capacity(100, stream); /// ``` #[stable(feature = "rust1", since = "1.0.0")] <del> pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> { </del> <ins> pub fn with_capacity(capacity: usize, inner: W) -> BufWriter<W> { </ins> BufWriter { inner: Some(inner), <del> buf: Vec::with_capacity(cap), </del> <ins> buf: Vec::with_capacity(capacity), </ins> panicked: false, } }

/// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] <del> pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> { </del> <ins> pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W> { </ins> LineWriter { <del> inner: BufWriter::with_capacity(cap, inner), </del> <ins> inner: BufWriter::with_capacity(capacity, inner), </ins> need_flush: false, } }

Wtf8Buf { bytes: Vec::new() } } <del> /// Creates a new, empty WTF-8 string with pre-allocated capacity for `n` bytes. </del> <ins> /// Creates a new, empty WTF-8 string with pre-allocated capacity for `capacity` bytes. </ins> #[inline] <del> pub fn with_capacity(n: usize) -> Wtf8Buf { Wtf8Buf { bytes: Vec::with_capacity(n) } </del> <ins> pub fn with_capacity(capacity: usize) -> Wtf8Buf { Wtf8Buf { bytes: Vec::with_capacity(capacity) } </ins> } /// Creates a WTF-8 string from a UTF-8 `String`.