From c1ecff1b1e2eb1c4a10e305dd6cc25d7a94436f6 Mon Sep 17 00:00:00 2001 From: marcandre Date: Mon, 17 May 2010 21:31:22 +0000 Subject: * hash.c: Documentation: change => in call-seq to ->. * enum.c: Documentation: whitespace fix for r27865 * error.c: ditto * file.c: ditto * io.c: ditto * load.c: ditto git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27869 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- enum.c | 168 ++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 84 insertions(+), 84 deletions(-) (limited to 'enum.c') diff --git a/enum.c b/enum.c index 2162ff8b15..823eef6aa4 100644 --- a/enum.c +++ b/enum.c @@ -56,8 +56,8 @@ grep_iter_i(VALUE i, VALUE args, int argc, VALUE *argv) /* * call-seq: - * enum.grep(pattern) ->array - * enum.grep(pattern) {| obj | block } ->array + * enum.grep(pattern) -> array + * enum.grep(pattern) {| obj | block } -> array * * Returns an array of every element in enum for which * Pattern === element. If the optional block is @@ -121,9 +121,9 @@ count_all_i(VALUE i, VALUE memop, int argc, VALUE *argv) /* * call-seq: - * enum.count ->int - * enum.count(item) ->int - * enum.count {| obj | block } ->int + * enum.count -> int + * enum.count(item) -> int + * enum.count {| obj | block } -> int * * Returns the number of items in enum, where #size is called * if it responds to it, otherwise the items are counted through @@ -179,10 +179,10 @@ find_i(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.detect(ifnone = nil) {| obj | block } ->obj or nil - * enum.find(ifnone = nil) {| obj | block } ->obj or nil - * enum.detect(ifnone = nil) ->an_enumerator - * enum.find(ifnone = nil) ->an_enumerator + * enum.detect(ifnone = nil) {| obj | block } -> obj or nil + * enum.find(ifnone = nil) {| obj | block } -> obj or nil + * enum.detect(ifnone = nil) -> an_enumerator + * enum.find(ifnone = nil) -> an_enumerator * * Passes each entry in enum to block. Returns the * first for which block is not false. If no @@ -244,9 +244,9 @@ find_index_iter_i(VALUE i, VALUE memop, int argc, VALUE *argv) /* * call-seq: - * enum.find_index(value) ->int or nil - * enum.find_index {| obj | block } ->int or nil - * enum.find_index ->an_enumerator + * enum.find_index(value) -> int or nil + * enum.find_index {| obj | block } -> int or nil + * enum.find_index -> an_enumerator * * Compares each entry in enum with value or passes * to block. Returns the index for the first for which the @@ -298,10 +298,10 @@ find_all_i(VALUE i, VALUE ary, int argc, VALUE *argv) /* * call-seq: - * enum.find_all {| obj | block } ->array - * enum.select {| obj | block } ->array - * enum.find_all ->an_enumerator - * enum.select ->an_enumerator + * enum.find_all {| obj | block } -> array + * enum.select {| obj | block } -> array + * enum.find_all -> an_enumerator + * enum.select -> an_enumerator * * Returns an array containing all elements of enum for which * block is not false (see also @@ -340,8 +340,8 @@ reject_i(VALUE i, VALUE ary, int argc, VALUE *argv) /* * call-seq: - * enum.reject {| obj | block } ->array - * enum.reject ->an_enumerator + * enum.reject {| obj | block } -> array + * enum.reject -> an_enumerator * * Returns an array for all elements of enum for which * block is false (see also Enumerable#find_all). @@ -384,10 +384,10 @@ collect_all(VALUE i, VALUE ary, int argc, VALUE *argv) /* * call-seq: - * enum.collect {| obj | block } ->array - * enum.map {| obj | block } ->array - * enum.collect ->an_enumerator - * enum.map ->an_enumerator + * enum.collect {| obj | block } -> array + * enum.map {| obj | block } -> array + * enum.collect -> an_enumerator + * enum.map -> an_enumerator * * Returns a new array with the results of running block once * for every element in enum. @@ -431,10 +431,10 @@ flat_map_i(VALUE i, VALUE ary, int argc, VALUE *argv) /* * call-seq: - * enum.flat_map {| obj | block } ->array - * enum.collect_concat {| obj | block } ->array - * enum.flat_map ->an_enumerator - * enum.collect_concat ->an_enumerator + * enum.flat_map {| obj | block } -> array + * enum.collect_concat {| obj | block } -> array + * enum.flat_map -> an_enumerator + * enum.collect_concat -> an_enumerator * * Returns a new array with the concatenated results of running * block once for every element in enum. @@ -460,8 +460,8 @@ enum_flat_map(VALUE obj) /* * call-seq: - * enum.to_a -> array - * enum.entries -> array + * enum.to_a -> array + * enum.entries -> array * * Returns an array containing the items in enum. * @@ -514,14 +514,14 @@ inject_op_i(VALUE i, VALUE p, int argc, VALUE *argv) /* * call-seq: * enum.inject(initial, sym)->obj - * enum.inject(sym) ->obj - * enum.inject(initial) {| memo, obj | block } ->obj - * enum.inject {| memo, obj | block } ->obj + * enum.inject(sym) -> obj + * enum.inject(initial) {| memo, obj | block } -> obj + * enum.inject {| memo, obj | block } -> obj * * enum.reduce(initial, sym)->obj - * enum.reduce(sym) ->obj - * enum.reduce(initial) {| memo, obj | block } ->obj - * enum.reduce {| memo, obj | block } ->obj + * enum.reduce(sym) -> obj + * enum.reduce(initial) {| memo, obj | block } -> obj + * enum.reduce {| memo, obj | block } -> obj * * Combines all elements of enum by applying a binary * operation, specified by a block or a symbol that names a @@ -603,8 +603,8 @@ partition_i(VALUE i, VALUE *ary, int argc, VALUE *argv) /* * call-seq: - * enum.partition {| obj | block } ->[ true_array, false_array ] - * enum.partition ->an_enumerator + * enum.partition {| obj | block } -> [ true_array, false_array ] + * enum.partition -> an_enumerator * * Returns two arrays, the first containing the elements of * enum for which the block evaluates to true, the second @@ -652,8 +652,8 @@ group_by_i(VALUE i, VALUE hash, int argc, VALUE *argv) /* * call-seq: - * enum.group_by {| obj | block } ->a_hash - * enum.group_by ->an_enumerator + * enum.group_by {| obj | block } -> a_hash + * enum.group_by -> an_enumerator * * Returns a hash, which keys are evaluated result from the * block, and values are arrays of elements in enum @@ -703,8 +703,8 @@ first_i(VALUE i, VALUE *params, int argc, VALUE *argv) /* * call-seq: - * enum.first -> obj or nil - * enum.first(n) -> an_array + * enum.first -> obj or nil + * enum.first(n) -> an_array * * Returns the first element, or the first +n+ elements, of the enumerable. * If the enumerable is empty, the first form returns nil, and the @@ -740,8 +740,8 @@ enum_first(int argc, VALUE *argv, VALUE obj) /* * call-seq: - * enum.sort ->array - * enum.sort {| a, b | block } ->array + * enum.sort -> array + * enum.sort {| a, b | block } -> array * * Returns an array containing the items in enum sorted, * either according to their own <=> method, or by using @@ -792,8 +792,8 @@ sort_by_cmp(const void *ap, const void *bp, void *data) /* * call-seq: - * enum.sort_by {| obj | block } ->array - * enum.sort_by ->an_enumerator + * enum.sort_by {| obj | block } -> array + * enum.sort_by -> an_enumerator * * Sorts enum using a set of keys generated by mapping the * values in enum through the given block. @@ -924,7 +924,7 @@ DEFINE_ENUMFUNCS(all) /* * call-seq: - * enum.all? [{|obj| block } ] ->true or false + * enum.all? [{|obj| block } ] -> true or false * * Passes each element of the collection to the given block. The method * returns true if the block never returns @@ -959,7 +959,7 @@ DEFINE_ENUMFUNCS(any) /* * call-seq: - * enum.any? [{|obj| block } ] ->true or false + * enum.any? [{|obj| block } ] -> true or false * * Passes each element of the collection to the given block. The method * returns true if the block ever returns a value other @@ -1000,7 +1000,7 @@ DEFINE_ENUMFUNCS(one) /* * call-seq: - * enum.one? [{|obj| block }] ->true or false + * enum.one? [{|obj| block }] -> true or false * * Passes each element of the collection to the given block. The method * returns true if the block returns true @@ -1037,7 +1037,7 @@ DEFINE_ENUMFUNCS(none) /* * call-seq: - * enum.none? [{|obj| block }] ->true or false + * enum.none? [{|obj| block }] -> true or false * * Passes each element of the collection to the given block. The method * returns true if the block never returns true @@ -1100,8 +1100,8 @@ min_ii(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.min ->obj - * enum.min {| a,b | block } ->obj + * enum.min -> obj + * enum.min {| a,b | block } -> obj * * Returns the object in enum with the minimum value. The * first form assumes all objects implement Comparable; @@ -1167,8 +1167,8 @@ max_ii(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.max ->obj - * enum.max {|a,b| block } ->obj + * enum.max -> obj + * enum.max {|a,b| block } -> obj * * Returns the object in _enum_ with the maximum value. The * first form assumes all objects implement Comparable; @@ -1306,8 +1306,8 @@ minmax_ii(VALUE i, VALUE _memo, int argc, VALUE *argv) /* * call-seq: - * enum.minmax ->[min,max] - * enum.minmax {|a,b| block } ->[min,max] + * enum.minmax -> [min,max] + * enum.minmax {|a,b| block } -> [min,max] * * Returns two elements array which contains the minimum and the * maximum value in the enumerable. The first form assumes all @@ -1365,8 +1365,8 @@ min_by_i(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.min_by {|obj| block } ->obj - * enum.min_by ->an_enumerator + * enum.min_by {|obj| block } -> obj + * enum.min_by -> an_enumerator * * Returns the object in enum that gives the minimum * value from the given block. @@ -1411,8 +1411,8 @@ max_by_i(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.max_by {|obj| block } ->obj - * enum.max_by ->an_enumerator + * enum.max_by {|obj| block } -> obj + * enum.max_by -> an_enumerator * * Returns the object in enum that gives the maximum * value from the given block. @@ -1508,8 +1508,8 @@ minmax_by_i(VALUE i, VALUE _memo, int argc, VALUE *argv) /* * call-seq: - * enum.minmax_by {|obj| block } ->[min, max] - * enum.minmax_by ->an_enumerator + * enum.minmax_by {|obj| block } -> [min, max] + * enum.minmax_by -> an_enumerator * * Returns two elements array array containing the objects in * enum that gives the minimum and maximum values respectively @@ -1552,8 +1552,8 @@ member_i(VALUE iter, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.include?(obj) ->true or false - * enum.member?(obj) ->true or false + * enum.include?(obj) -> true or false + * enum.member?(obj) -> true or false * * Returns true if any member of enum equals * obj. Equality is tested using ==. @@ -1584,8 +1584,8 @@ each_with_index_i(VALUE i, VALUE memo, int argc, VALUE *argv) /* * call-seq: - * enum.each_with_index(*args) {|obj, i| block } -> enum - * enum.each_with_index(*args) -> an_enumerator + * enum.each_with_index(*args) {|obj, i| block } -> enum + * enum.each_with_index(*args) -> an_enumerator * * Calls block with two arguments, the item and its index, * for each item in enum. Given arguments are passed through @@ -1616,8 +1616,8 @@ enum_each_with_index(int argc, VALUE *argv, VALUE obj) /* * call-seq: - * enum.reverse_each(*args) {|item| block } -> enum - * enum.reverse_each(*args) -> an_enumerator + * enum.reverse_each(*args) {|item| block } -> enum + * enum.reverse_each(*args) -> an_enumerator * * Builds a temporary array and traverses that array in reverse order. * @@ -1653,8 +1653,8 @@ each_val_i(VALUE i, VALUE p, int argc, VALUE *argv) /* * call-seq: - * enum.each_entry {|obj| block} ->enum - * enum.each_entry ->an_enumerator + * enum.each_entry {|obj| block} -> enum + * enum.each_entry -> an_enumerator * * Calls block once for each element in +self+, passing that * element as a parameter, converting multiple values from yield to an @@ -1704,8 +1704,8 @@ each_slice_i(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.each_slice(n) {...} -> nil - * enum.each_slice(n) -> an_enumerator + * enum.each_slice(n) {...} -> nil + * enum.each_slice(n) -> an_enumerator * * Iterates the given block for each slice of elements. If no * block is given, returns an enumerator. @@ -1758,8 +1758,8 @@ each_cons_i(VALUE i, VALUE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.each_cons(n) {...} -> nil - * enum.each_cons(n) -> an_enumerator + * enum.each_cons(n) {...} -> nil + * enum.each_cons(n) -> an_enumerator * * Iterates the given block for each array of consecutive * elements. If no block is given, returns an enumerator. @@ -1802,8 +1802,8 @@ each_with_object_i(VALUE i, VALUE memo, int argc, VALUE *argv) /* * call-seq: - * enum.each_with_object(obj) {|(*args), memo_obj| ... } -> obj - * enum.each_with_object(obj) -> an_enumerator + * enum.each_with_object(obj) {|(*args), memo_obj| ... } -> obj + * enum.each_with_object(obj) -> an_enumerator * * Iterates the given block for each element with an arbitrary * object given, and returns the initially given object. @@ -1904,8 +1904,8 @@ zip_i(VALUE val, NODE *memo, int argc, VALUE *argv) /* * call-seq: - * enum.zip(arg, ...) ->an_enumerator - * enum.zip(arg, ...) {|arr| block } ->nil + * enum.zip(arg, ...) -> an_enumerator + * enum.zip(arg, ...) {|arr| block } -> nil * * Takes one element from enum and merges corresponding * elements from each args. This generates a sequence of @@ -1970,7 +1970,7 @@ take_i(VALUE i, VALUE *arg, int argc, VALUE *argv) /* * call-seq: - * enum.take(n) ->array + * enum.take(n) -> array * * Returns first n elements from enum. * @@ -2007,8 +2007,8 @@ take_while_i(VALUE i, VALUE *ary, int argc, VALUE *argv) /* * call-seq: - * enum.take_while {|arr| block } ->array - * enum.take_while ->an_enumerator + * enum.take_while {|arr| block } -> array + * enum.take_while -> an_enumerator * * Passes elements to the block until the block returns +nil+ or +false+, * then stops iterating and returns an array of all prior elements. @@ -2045,7 +2045,7 @@ drop_i(VALUE i, VALUE *arg, int argc, VALUE *argv) /* * call-seq: - * enum.drop(n) ->array + * enum.drop(n) -> array * * Drops first n elements from enum, and returns rest elements * in an array. @@ -2088,8 +2088,8 @@ drop_while_i(VALUE i, VALUE *args, int argc, VALUE *argv) /* * call-seq: - * enum.drop_while {|arr| block } ->array - * enum.drop_while ->an_enumerator + * enum.drop_while {|arr| block } -> array + * enum.drop_while -> an_enumerator * * Drops elements up to, but not including, the first element for * which the block returns +nil+ or +false+ and returns an array @@ -2126,8 +2126,8 @@ cycle_i(VALUE i, VALUE ary, int argc, VALUE *argv) /* * call-seq: - * enum.cycle(n=nil) {|obj| block } -> nil - * enum.cycle(n=nil) -> an_enumerator + * enum.cycle(n=nil) {|obj| block } -> nil + * enum.cycle(n=nil) -> an_enumerator * * Calls block for each element of enum repeatedly _n_ * times or forever if none or +nil+ is given. If a non-positive -- cgit v1.2.3