[DOC] Change arg names from n to count (#12288)

BurdetteLamar · web-flow · commit 50a67820fbbb · 2024-12-17T10:55:43.000-05:00
diff --git a/array.c b/array.c
@@ -5973,9 +5973,9 @@ ary_max_opt_string(VALUE ary, long i, VALUE vmax)
 /*
  *  call-seq:
  *    max -> element
- *    max(n) -> new_array
+ *    max(count) -> new_array
  *    max {|a, b| ... } -> element
- *    max(n) {|a, b| ... } -> new_array
+ *    max(count) {|a, b| ... } -> new_array
  *
  *  Returns one of the following:
  *
@@ -5992,8 +5992,8 @@ ary_max_opt_string(VALUE ary, long i, VALUE vmax)
  *
  *    [1, 0, 3, 2].max # => 3
  *
- *  With non-negative numeric argument +n+ and no block,
- *  returns a new array with at most +n+ elements,
+ *  With non-negative numeric argument +count+ and no block,
+ *  returns a new array with at most +count+ elements,
  *  in descending order, per method <tt>#<=></tt>:
  *
  *    [1, 0, 3, 2].max(3)   # => [3, 2, 1]
@@ -6009,8 +6009,8 @@ ary_max_opt_string(VALUE ary, long i, VALUE vmax)
  *    ['0', '', '000', '00'].max {|a, b| a.size <=> b.size }
  *    # => "000"
  *
- *  With non-negative numeric argument +n+ and a block,
- *  returns a new array with at most +n+ elements,
+ *  With non-negative numeric argument +count+ and a block,
+ *  returns a new array with at most +count+ elements,
  *  in descending order, per the block:
  *
  *    ['0', '', '000', '00'].max(2) {|a, b| a.size <=> b.size }
@@ -6150,9 +6150,9 @@ ary_min_opt_string(VALUE ary, long i, VALUE vmin)
 /*
  *  call-seq:
  *    min -> element
- *    min(n) -> new_array
+ *    min(count) -> new_array
  *    min {|a, b| ... } -> element
- *    min(n) {|a, b| ... } -> new_array
+ *    min(count) {|a, b| ... } -> new_array
  *
  *  Returns one of the following:
  *
@@ -6169,8 +6169,8 @@ ary_min_opt_string(VALUE ary, long i, VALUE vmin)
  *
  *    [1, 0, 3, 2].min # => 0
  *
- *  With non-negative numeric argument +n+ and no block,
- *  returns a new array with at most +n+ elements,
+ *  With non-negative numeric argument +count+ and no block,
+ *  returns a new array with at most +count+ elements,
  *  in ascending order, per method <tt>#<=></tt>:
  *
  *    [1, 0, 3, 2].min(3)   # => [0, 1, 2]
@@ -6186,8 +6186,8 @@ ary_min_opt_string(VALUE ary, long i, VALUE vmin)
  *    ['0', '', '000', '00'].min {|a, b| a.size <=> b.size }
  *    # => ""
  *
- *  With non-negative numeric argument +n+ and a block,
- *  returns a new array with at most +n+ elements,
+ *  With non-negative numeric argument +count+ and a block,
+ *  returns a new array with at most +count+ elements,
  *  in ascending order, per the block:
  *
  *    ['0', '', '000', '00'].min(2) {|a, b| a.size <=> b.size }
@@ -7063,14 +7063,14 @@ rb_ary_permutation_size(VALUE ary, VALUE args, VALUE eobj)
 
 /*
  *  call-seq:
- *    permutation(n = self.size) {|permutation| ... } -> self
- *    permutation(n = self.size) -> new_enumerator
+ *    permutation(count = self.size) {|permutation| ... } -> self
+ *    permutation(count = self.size) -> new_enumerator
  *
  *  Iterates over permutations of the elements of +self+;
  *  the order of permutations is indeterminate.
  *
- *  With a block and an in-range positive integer argument +n+ (<tt>0 < n <= self.size</tt>) given,
- *  calls the block with each +n+-tuple permutations of +self+;
+ *  With a block and an in-range positive integer argument +count+ (<tt>0 < count <= self.size</tt>) given,
+ *  calls the block with each permutation of +self+ of size +count+;
  *  returns +self+:
  *
  *    a = [0, 1, 2]
@@ -7086,13 +7086,13 @@ rb_ary_permutation_size(VALUE ary, VALUE args, VALUE eobj)
  *    a.permutation(3) {|perm| perms.push(perm) }
  *    perms # => [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]
  *
- *  When +n+ is zero, calls the block once with a new empty array:
+ *  When +count+ is zero, calls the block once with a new empty array:
  *
  *    perms = []
  *    a.permutation(0) {|perm| perms.push(perm) }
  *    perms # => [[]]
  *
- *  When +n+ is out of range (negative or larger than <tt>self.size</tt>),
+ *  When +count+ is out of range (negative or larger than <tt>self.size</tt>),
  *  does not call the block:
  *
  *    a.permutation(-1) {|permutation| fail 'Cannot happen' }
@@ -7173,13 +7173,13 @@ rb_ary_combination_size(VALUE ary, VALUE args, VALUE eobj)
 
 /*
  *  call-seq:
- *    combination(n) {|element| ... } -> self
- *    combination(n) -> new_enumerator
+ *    combination(count) {|element| ... } -> self
+ *    combination(count) -> new_enumerator
  *
  *  When a block and a positive
  *  {integer-convertible object}[rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects]
- *  argument +n+ (<tt>0 < n <= self.size</tt>)
- *  are given, calls the block with all +n+-tuple combinations of +self+;
+ *  argument +count+ (<tt>0 < count <= self.size</tt>)
+ *  are given, calls the block with each combination of +self+ of size +count+;
  *  returns +self+:
  *
  *    a = %w[a b c]                                   # => ["a", "b", "c"]
@@ -7193,7 +7193,7 @@ rb_ary_combination_size(VALUE ary, VALUE args, VALUE eobj)
  *
  *  The order of the yielded combinations is not guaranteed.
  *
- *  When +n+ is zero, calls the block once with a new empty array:
+ *  When +count+ is zero, calls the block once with a new empty array:
  *
  *    a.combination(0) {|combination| p combination }
  *    [].combination(0) {|combination| p combination }
@@ -7203,7 +7203,7 @@ rb_ary_combination_size(VALUE ary, VALUE args, VALUE eobj)
  *    []
  *    []
  *
- *  When +n+ is negative or larger than +self.size+ and +self+ is non-empty,
+ *  When +count+ is negative or larger than +self.size+ and +self+ is non-empty,
  *  does not call the block:
  *
  *    a.combination(-1) {|combination| fail 'Cannot happen' } # => ["a", "b", "c"]
@@ -7680,10 +7680,10 @@ rb_ary_take_while(VALUE ary)
 
 /*
  *  call-seq:
- *    drop(n) -> new_array
+ *    drop(count) -> new_array
  *
- *  Returns a new array containing all but the first +n+ element of +self+,
- *  where +n+ is a non-negative Integer;
+ *  Returns a new array containing all but the first +count+ element of +self+,
+ *  where +count+ is a non-negative integer;
  *  does not modify +self+.
  *
  *  Examples:
diff --git a/array.rb b/array.rb
@@ -140,8 +140,8 @@ def first n = unspecified = true
   end
 
   # call-seq:
-  #   last  -> last_object or nil
-  #   last(n) -> new_array
+  #  last  -> last_object or nil
+  #  last(count) -> new_array
   #
   # Returns elements from +self+, or +nil+; +self+ is not modified.
   #
@@ -152,8 +152,9 @@ def first n = unspecified = true
   #   a # => [:foo, "bar", 2]
   #   [].last # => nil
   #
-  # With a non-negative integer argument +n+ given,
-  # returns a new array containing the trailing +n+ elements of +self+, as available:
+  #
+  # With non-negative integer argument +count+ given,
+  # returns a new array containing the trailing +count+ elements of +self+, as available:
   #
   #   a = [:foo, 'bar', 2]
   #   a.last(2)  # => ["bar", 2]

Original file line number	Diff line number	Diff line change
`@@ -5973,9 +5973,9 @@ ary_max_opt_string(VALUE ary, long i, VALUE vmax)`
`5973`	`5973`	`/*`
`5974`	`5974`	`* call-seq:`
`5975`	`5975`	`* max -> element`
`5976`		`- * max(n) -> new_array`
	`5976`	`+ * max(count) -> new_array`
`5977`	`5977`	`* max {\|a, b\| ... } -> element`
`5978`		`- * max(n) {\|a, b\| ... } -> new_array`
	`5978`	`+ * max(count) {\|a, b\| ... } -> new_array`
`5979`	`5979`	`*`
`5980`	`5980`	`* Returns one of the following:`
`5981`	`5981`	`*`
`@@ -5992,8 +5992,8 @@ ary_max_opt_string(VALUE ary, long i, VALUE vmax)`
`5992`	`5992`	`*`
`5993`	`5993`	`* [1, 0, 3, 2].max # => 3`
`5994`	`5994`	`*`
`5995`		`- * With non-negative numeric argument +n+ and no block,`
`5996`		`- * returns a new array with at most +n+ elements,`
	`5995`	`+ * With non-negative numeric argument +count+ and no block,`
	`5996`	`+ * returns a new array with at most +count+ elements,`
`5997`	`5997`	`* in descending order, per method <tt>#<=></tt>:`
`5998`	`5998`	`*`
`5999`	`5999`	`* [1, 0, 3, 2].max(3) # => [3, 2, 1]`
`@@ -6009,8 +6009,8 @@ ary_max_opt_string(VALUE ary, long i, VALUE vmax)`
`6009`	`6009`	`* ['0', '', '000', '00'].max {\|a, b\| a.size <=> b.size }`
`6010`	`6010`	`* # => "000"`
`6011`	`6011`	`*`
`6012`		`- * With non-negative numeric argument +n+ and a block,`
`6013`		`- * returns a new array with at most +n+ elements,`
	`6012`	`+ * With non-negative numeric argument +count+ and a block,`
	`6013`	`+ * returns a new array with at most +count+ elements,`
`6014`	`6014`	`* in descending order, per the block:`
`6015`	`6015`	`*`
`6016`	`6016`	`* ['0', '', '000', '00'].max(2) {\|a, b\| a.size <=> b.size }`
`@@ -6150,9 +6150,9 @@ ary_min_opt_string(VALUE ary, long i, VALUE vmin)`
`6150`	`6150`	`/*`
`6151`	`6151`	`* call-seq:`
`6152`	`6152`	`* min -> element`
`6153`		`- * min(n) -> new_array`
	`6153`	`+ * min(count) -> new_array`
`6154`	`6154`	`* min {\|a, b\| ... } -> element`
`6155`		`- * min(n) {\|a, b\| ... } -> new_array`
	`6155`	`+ * min(count) {\|a, b\| ... } -> new_array`
`6156`	`6156`	`*`
`6157`	`6157`	`* Returns one of the following:`
`6158`	`6158`	`*`
`@@ -6169,8 +6169,8 @@ ary_min_opt_string(VALUE ary, long i, VALUE vmin)`
`6169`	`6169`	`*`
`6170`	`6170`	`* [1, 0, 3, 2].min # => 0`
`6171`	`6171`	`*`
`6172`		`- * With non-negative numeric argument +n+ and no block,`
`6173`		`- * returns a new array with at most +n+ elements,`
	`6172`	`+ * With non-negative numeric argument +count+ and no block,`
	`6173`	`+ * returns a new array with at most +count+ elements,`
`6174`	`6174`	`* in ascending order, per method <tt>#<=></tt>:`
`6175`	`6175`	`*`
`6176`	`6176`	`* [1, 0, 3, 2].min(3) # => [0, 1, 2]`
`@@ -6186,8 +6186,8 @@ ary_min_opt_string(VALUE ary, long i, VALUE vmin)`
`6186`	`6186`	`* ['0', '', '000', '00'].min {\|a, b\| a.size <=> b.size }`
`6187`	`6187`	`* # => ""`
`6188`	`6188`	`*`
`6189`		`- * With non-negative numeric argument +n+ and a block,`
`6190`		`- * returns a new array with at most +n+ elements,`
	`6189`	`+ * With non-negative numeric argument +count+ and a block,`
	`6190`	`+ * returns a new array with at most +count+ elements,`
`6191`	`6191`	`* in ascending order, per the block:`
`6192`	`6192`	`*`
`6193`	`6193`	`* ['0', '', '000', '00'].min(2) {\|a, b\| a.size <=> b.size }`
`@@ -7063,14 +7063,14 @@ rb_ary_permutation_size(VALUE ary, VALUE args, VALUE eobj)`
`7063`	`7063`
`7064`	`7064`	`/*`
`7065`	`7065`	`* call-seq:`
`7066`		`- * permutation(n = self.size) {\|permutation\| ... } -> self`
`7067`		`- * permutation(n = self.size) -> new_enumerator`
	`7066`	`+ * permutation(count = self.size) {\|permutation\| ... } -> self`
	`7067`	`+ * permutation(count = self.size) -> new_enumerator`
`7068`	`7068`	`*`
`7069`	`7069`	`* Iterates over permutations of the elements of +self+;`
`7070`	`7070`	`* the order of permutations is indeterminate.`
`7071`	`7071`	`*`
`7072`		`- * With a block and an in-range positive integer argument +n+ (<tt>0 < n <= self.size</tt>) given,`
`7073`		`- * calls the block with each +n+-tuple permutations of +self+;`
	`7072`	`+ * With a block and an in-range positive integer argument +count+ (<tt>0 < count <= self.size</tt>) given,`
	`7073`	`+ * calls the block with each permutation of +self+ of size +count+;`
`7074`	`7074`	`* returns +self+:`
`7075`	`7075`	`*`
`7076`	`7076`	`* a = [0, 1, 2]`
`@@ -7086,13 +7086,13 @@ rb_ary_permutation_size(VALUE ary, VALUE args, VALUE eobj)`
`7086`	`7086`	`* a.permutation(3) {\|perm\| perms.push(perm) }`
`7087`	`7087`	`* perms # => [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]`
`7088`	`7088`	`*`
`7089`		`- * When +n+ is zero, calls the block once with a new empty array:`
	`7089`	`+ * When +count+ is zero, calls the block once with a new empty array:`
`7090`	`7090`	`*`
`7091`	`7091`	`* perms = []`
`7092`	`7092`	`* a.permutation(0) {\|perm\| perms.push(perm) }`
`7093`	`7093`	`* perms # => [[]]`
`7094`	`7094`	`*`
`7095`		`- * When +n+ is out of range (negative or larger than <tt>self.size</tt>),`
	`7095`	`+ * When +count+ is out of range (negative or larger than <tt>self.size</tt>),`
`7096`	`7096`	`* does not call the block:`
`7097`	`7097`	`*`
`7098`	`7098`	`* a.permutation(-1) {\|permutation\| fail 'Cannot happen' }`
`@@ -7173,13 +7173,13 @@ rb_ary_combination_size(VALUE ary, VALUE args, VALUE eobj)`
`7173`	`7173`
`7174`	`7174`	`/*`
`7175`	`7175`	`* call-seq:`
`7176`		`- * combination(n) {\|element\| ... } -> self`
`7177`		`- * combination(n) -> new_enumerator`
	`7176`	`+ * combination(count) {\|element\| ... } -> self`
	`7177`	`+ * combination(count) -> new_enumerator`
`7178`	`7178`	`*`
`7179`	`7179`	`* When a block and a positive`
`7180`	`7180`	`* {integer-convertible object}[rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects]`
`7181`		`- * argument +n+ (<tt>0 < n <= self.size</tt>)`
`7182`		`- * are given, calls the block with all +n+-tuple combinations of +self+;`
	`7181`	`+ * argument +count+ (<tt>0 < count <= self.size</tt>)`
	`7182`	`+ * are given, calls the block with each combination of +self+ of size +count+;`
`7183`	`7183`	`* returns +self+:`
`7184`	`7184`	`*`
`7185`	`7185`	`* a = %w[a b c] # => ["a", "b", "c"]`
`@@ -7193,7 +7193,7 @@ rb_ary_combination_size(VALUE ary, VALUE args, VALUE eobj)`
`7193`	`7193`	`*`
`7194`	`7194`	`* The order of the yielded combinations is not guaranteed.`
`7195`	`7195`	`*`
`7196`		`- * When +n+ is zero, calls the block once with a new empty array:`
	`7196`	`+ * When +count+ is zero, calls the block once with a new empty array:`
`7197`	`7197`	`*`
`7198`	`7198`	`* a.combination(0) {\|combination\| p combination }`
`7199`	`7199`	`* [].combination(0) {\|combination\| p combination }`
`@@ -7203,7 +7203,7 @@ rb_ary_combination_size(VALUE ary, VALUE args, VALUE eobj)`
`7203`	`7203`	`* []`
`7204`	`7204`	`* []`
`7205`	`7205`	`*`
`7206`		`- * When +n+ is negative or larger than +self.size+ and +self+ is non-empty,`
	`7206`	`+ * When +count+ is negative or larger than +self.size+ and +self+ is non-empty,`
`7207`	`7207`	`* does not call the block:`
`7208`	`7208`	`*`
`7209`	`7209`	`* a.combination(-1) {\|combination\| fail 'Cannot happen' } # => ["a", "b", "c"]`
`@@ -7680,10 +7680,10 @@ rb_ary_take_while(VALUE ary)`
`7680`	`7680`
`7681`	`7681`	`/*`
`7682`	`7682`	`* call-seq:`
`7683`		`- * drop(n) -> new_array`
	`7683`	`+ * drop(count) -> new_array`
`7684`	`7684`	`*`
`7685`		`- * Returns a new array containing all but the first +n+ element of +self+,`
`7686`		`- * where +n+ is a non-negative Integer;`
	`7685`	`+ * Returns a new array containing all but the first +count+ element of +self+,`
	`7686`	`+ * where +count+ is a non-negative integer;`
`7687`	`7687`	`* does not modify +self+.`
`7688`	`7688`	`*`
`7689`	`7689`	`* Examples:`
Original file line number	Diff line number	Diff line change
`@@ -140,8 +140,8 @@ def first n = unspecified = true`
`140`	`140`	`end`
`141`	`141`
`142`	`142`	`# call-seq:`
`143`		`- # last -> last_object or nil`
`144`		`- # last(n) -> new_array`
	`143`	`+ # last -> last_object or nil`
	`144`	`+ # last(count) -> new_array`
`145`	`145`	`#`
`146`	`146`	`# Returns elements from +self+, or +nil+; +self+ is not modified.`
`147`	`147`	`#`
`@@ -152,8 +152,9 @@ def first n = unspecified = true`
`152`	`152`	`# a # => [:foo, "bar", 2]`
`153`	`153`	`# [].last # => nil`
`154`	`154`	`#`
`155`		`- # With a non-negative integer argument +n+ given,`
`156`		`- # returns a new array containing the trailing +n+ elements of +self+, as available:`
	`155`	`+ #`
	`156`	`+ # With non-negative integer argument +count+ given,`
	`157`	`+ # returns a new array containing the trailing +count+ elements of +self+, as available:`
`157`	`158`	`#`
`158`	`159`	`# a = [:foo, 'bar', 2]`
`159`	`160`	`# a.last(2) # => ["bar", 2]`