Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse code

* array.c: Documentation: change => in call-seq to ->.

            Harmonize "#=>" in examples. [ruby-core:30206]

* bignum.c: ditto

* class.c: ditto

* compar.c: ditto

* cont.c: ditto

* dir.c: ditto

* encoding.c: ditto

* enum.c: ditto

* enumerator.c: ditto

* error.c: ditto

* eval.c: ditto

* file.c: ditto

* gc.c: ditto

* io.c: ditto

* load.c: ditto

* marshal.c: ditto

* math.c: ditto

* numeric.c: ditto

* object.c: ditto

* pack.c: ditto

* proc.c: ditto

* process.c: ditto

* random.c: ditto

* range.c: ditto

* re.c: ditto

* ruby.c: ditto

* signal.c: ditto

* sprintf.c: ditto

* string.c: ditto

* struct.c: ditto

* thread.c: ditto

* time.c: ditto

* transcode.c: ditto

* variable.c: ditto

* vm_eval.c: ditto

* vm_method.c: ditto

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27865 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
  • Loading branch information...
commit 494ee476ca20cdd6396148b4a546c04d71f17b16 1 parent 4a0ace5
Marc-André Lafortune authored
28  array.c
@@ -479,8 +479,8 @@ rb_check_array_type(VALUE ary)
479 479
  *  for any reason. This method can be used to check if an argument is an
480 480
  *  array.
481 481
  *
482  
- *     Array.try_convert([1])   # => [1]
483  
- *     Array.try_convert("1")   # => nil
  482
+ *     Array.try_convert([1])   #=> [1]
  483
+ *     Array.try_convert("1")   #=> nil
484 484
  *
485 485
  *     if tmp = Array.try_convert(arg)
486 486
  *       # the argument is an array
@@ -3559,9 +3559,9 @@ rb_ary_compact(VALUE ary)
3559 3559
  *  given, counts the number of elements yielding a true value.
3560 3560
  *
3561 3561
  *     ary = [1, 2, 4, 2]
3562  
- *     ary.count             # => 4
3563  
- *     ary.count(2)          # => 2
3564  
- *     ary.count{|x|x%2==0}  # => 3
  3562
+ *     ary.count             #=> 4
  3563
+ *     ary.count(2)          #=> 2
  3564
+ *     ary.count{|x|x%2==0}  #=> 3
3565 3565
  *
3566 3566
  */
3567 3567
 
@@ -4282,12 +4282,12 @@ rb_ary_repeated_combination(VALUE ary, VALUE num)
4282 4282
  *  and return +self+ instead.
4283 4283
  *
4284 4284
  *
4285  
- *     [1,2,3].product([4,5])     # => [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
4286  
- *     [1,2].product([1,2])       # => [[1,1],[1,2],[2,1],[2,2]]
4287  
- *     [1,2].product([3,4],[5,6]) # => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],
  4285
+ *     [1,2,3].product([4,5])     #=> [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
  4286
+ *     [1,2].product([1,2])       #=> [[1,1],[1,2],[2,1],[2,2]]
  4287
+ *     [1,2].product([3,4],[5,6]) #=> [[1,3,5],[1,3,6],[1,4,5],[1,4,6],
4288 4288
  *                                #     [2,3,5],[2,3,6],[2,4,5],[2,4,6]]
4289  
- *     [1,2].product()            # => [[1],[2]]
4290  
- *     [1,2].product([])          # => []
  4289
+ *     [1,2].product()            #=> [[1],[2]]
  4290
+ *     [1,2].product([])          #=> []
4291 4291
  */
4292 4292
 
4293 4293
 static VALUE
@@ -4381,7 +4381,7 @@ rb_ary_product(int argc, VALUE *argv, VALUE ary)
4381 4381
  *  Returns first n elements from <i>ary</i>.
4382 4382
  *
4383 4383
  *     a = [1, 2, 3, 4, 5, 0]
4384  
- *     a.take(3)             # => [1, 2, 3]
  4384
+ *     a.take(3)             #=> [1, 2, 3]
4385 4385
  *
4386 4386
  */
4387 4387
 
@@ -4406,7 +4406,7 @@ rb_ary_take(VALUE obj, VALUE n)
4406 4406
  *  If no block is given, an enumerator is returned instead.
4407 4407
  *
4408 4408
  *     a = [1, 2, 3, 4, 5, 0]
4409  
- *     a.take_while {|i| i < 3 }   # => [1, 2]
  4409
+ *     a.take_while {|i| i < 3 }   #=> [1, 2]
4410 4410
  *
4411 4411
  */
4412 4412
 
@@ -4430,7 +4430,7 @@ rb_ary_take_while(VALUE ary)
4430 4430
  *  in an array.
4431 4431
  *
4432 4432
  *     a = [1, 2, 3, 4, 5, 0]
4433  
- *     a.drop(3)             # => [4, 5, 0]
  4433
+ *     a.drop(3)             #=> [4, 5, 0]
4434 4434
  *
4435 4435
  */
4436 4436
 
@@ -4460,7 +4460,7 @@ rb_ary_drop(VALUE ary, VALUE n)
4460 4460
  *  If no block is given, an enumerator is returned instead.
4461 4461
  *
4462 4462
  *     a = [1, 2, 3, 4, 5, 0]
4463  
- *     a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]
  4463
+ *     a.drop_while {|i| i < 3 }   #=> [3, 4, 5, 0]
4464 4464
  *
4465 4465
  */
4466 4466
 
44  bignum.c
@@ -1112,7 +1112,7 @@ rb_big2str(VALUE x, int base)
1112 1112
 
1113 1113
 /*
1114 1114
  *  call-seq:
1115  
- *     big.to_s(base=10)   =>  string
  1115
+ *     big.to_s(base=10)   ->  string
1116 1116
  *
1117 1117
  *  Returns a string containing the representation of <i>big</i> radix
1118 1118
  *  <i>base</i> (2 through 36).
@@ -1382,7 +1382,7 @@ rb_big_to_f(VALUE x)
1382 1382
 
1383 1383
 /*
1384 1384
  *  call-seq:
1385  
- *     big <=> numeric   => -1, 0, +1 or nil
  1385
+ *     big <=> numeric   -> -1, 0, +1 or nil
1386 1386
  *
1387 1387
  *  Comparison---Returns -1, 0, or +1 depending on whether <i>big</i> is
1388 1388
  *  less than, equal to, or greater than <i>numeric</i>. This is the
@@ -1543,7 +1543,7 @@ big_le(VALUE x, VALUE y)
1543 1543
 
1544 1544
 /*
1545 1545
  *  call-seq:
1546  
- *     big == obj  => true or false
  1546
+ *     big == obj  -> true or false
1547 1547
  *
1548 1548
  *  Returns <code>true</code> only if <i>obj</i> has the same value
1549 1549
  *  as <i>big</i>. Contrast this with <code>Bignum#eql?</code>, which
@@ -1581,7 +1581,7 @@ rb_big_eq(VALUE x, VALUE y)
1581 1581
 
1582 1582
 /*
1583 1583
  *  call-seq:
1584  
- *     big.eql?(obj)   => true or false
  1584
+ *     big.eql?(obj)   -> true or false
1585 1585
  *
1586 1586
  *  Returns <code>true</code> only if <i>obj</i> is a
1587 1587
  *  <code>Bignum</code> with the same value as <i>big</i>. Contrast this
@@ -1602,7 +1602,7 @@ rb_big_eql(VALUE x, VALUE y)
1602 1602
 
1603 1603
 /*
1604 1604
  * call-seq:
1605  
- *    -big   =>  integer
  1605
+ *    -big   ->  integer
1606 1606
  *
1607 1607
  * Unary minus (returns an integer whose value is 0-big)
1608 1608
  */
@@ -1619,7 +1619,7 @@ rb_big_uminus(VALUE x)
1619 1619
 
1620 1620
 /*
1621 1621
  * call-seq:
1622  
- *     ~big  =>  integer
  1622
+ *     ~big  ->  integer
1623 1623
  *
1624 1624
  * Inverts the bits in big. As Bignums are conceptually infinite
1625 1625
  * length, the result acts as if it had an infinite number of one
@@ -1876,7 +1876,7 @@ bigadd(VALUE x, VALUE y, int sign)
1876 1876
 
1877 1877
 /*
1878 1878
  *  call-seq:
1879  
- *     big + other  => Numeric
  1879
+ *     big + other  -> Numeric
1880 1880
  *
1881 1881
  *  Adds big and other, returning the result.
1882 1882
  */
@@ -1913,7 +1913,7 @@ rb_big_plus(VALUE x, VALUE y)
1913 1913
 
1914 1914
 /*
1915 1915
  *  call-seq:
1916  
- *     big - other  => Numeric
  1916
+ *     big - other  -> Numeric
1917 1917
  *
1918 1918
  *  Subtracts other from big, returning the result.
1919 1919
  */
@@ -2273,7 +2273,7 @@ bigmul0(VALUE x, VALUE y)
2273 2273
 
2274 2274
 /*
2275 2275
  *  call-seq:
2276  
- *     big * other  => Numeric
  2276
+ *     big * other  -> Numeric
2277 2277
  *
2278 2278
  *  Multiplies big and other, returning the result.
2279 2279
  */
@@ -2522,7 +2522,7 @@ rb_big_divide(VALUE x, VALUE y, ID op)
2522 2522
 
2523 2523
 /*
2524 2524
  *  call-seq:
2525  
- *     big / other     => Numeric
  2525
+ *     big / other     -> Numeric
2526 2526
  *
2527 2527
  * Performs division: the class of the resulting object depends on
2528 2528
  * the class of <code>numeric</code> and on the magnitude of the
@@ -2537,7 +2537,7 @@ rb_big_div(VALUE x, VALUE y)
2537 2537
 
2538 2538
 /*
2539 2539
  *  call-seq:
2540  
- *     big.div(other)  => integer
  2540
+ *     big.div(other)  -> integer
2541 2541
  *
2542 2542
  * Performs integer division: returns integer value.
2543 2543
  */
@@ -2550,8 +2550,8 @@ rb_big_idiv(VALUE x, VALUE y)
2550 2550
 
2551 2551
 /*
2552 2552
  *  call-seq:
2553  
- *     big % other         => Numeric
2554  
- *     big.modulo(other)   => Numeric
  2553
+ *     big % other         -> Numeric
  2554
+ *     big.modulo(other)   -> Numeric
2555 2555
  *
2556 2556
  *  Returns big modulo other. See Numeric.divmod for more
2557 2557
  *  information.
@@ -2580,7 +2580,7 @@ rb_big_modulo(VALUE x, VALUE y)
2580 2580
 
2581 2581
 /*
2582 2582
  *  call-seq:
2583  
- *     big.remainder(numeric)    => number
  2583
+ *     big.remainder(numeric)    -> number
2584 2584
  *
2585 2585
  *  Returns the remainder after dividing <i>big</i> by <i>numeric</i>.
2586 2586
  *
@@ -2610,7 +2610,7 @@ rb_big_remainder(VALUE x, VALUE y)
2610 2610
 
2611 2611
 /*
2612 2612
  *  call-seq:
2613  
- *     big.divmod(numeric)   => array
  2613
+ *     big.divmod(numeric)   -> array
2614 2614
  *
2615 2615
  *  See <code>Numeric#divmod</code>.
2616 2616
  *
@@ -2770,7 +2770,7 @@ bigsqr(VALUE x)
2770 2770
 
2771 2771
 /*
2772 2772
  *  call-seq:
2773  
- *     big ** exponent   => numeric
  2773
+ *     big ** exponent   -> numeric
2774 2774
  *
2775 2775
  *  Raises _big_ to the _exponent_ power (which may be an integer, float,
2776 2776
  *  or anything that will coerce to a number). The result may be
@@ -2891,7 +2891,7 @@ bigand_int(VALUE x, long y)
2891 2891
 
2892 2892
 /*
2893 2893
  * call-seq:
2894  
- *     big & numeric   =>  integer
  2894
+ *     big & numeric   ->  integer
2895 2895
  *
2896 2896
  * Performs bitwise +and+ between _big_ and _numeric_.
2897 2897
  */
@@ -2982,7 +2982,7 @@ bigor_int(VALUE x, long y)
2982 2982
 
2983 2983
 /*
2984 2984
  * call-seq:
2985  
- *     big | numeric   =>  integer
  2985
+ *     big | numeric   ->  integer
2986 2986
  *
2987 2987
  * Performs bitwise +or+ between _big_ and _numeric_.
2988 2988
  */
@@ -3073,7 +3073,7 @@ bigxor_int(VALUE x, long y)
3073 3073
 }
3074 3074
 /*
3075 3075
  * call-seq:
3076  
- *     big ^ numeric   =>  integer
  3076
+ *     big ^ numeric   ->  integer
3077 3077
  *
3078 3078
  * Performs bitwise +exclusive or+ between _big_ and _numeric_.
3079 3079
  */
@@ -3143,7 +3143,7 @@ check_shiftdown(VALUE y, VALUE x)
3143 3143
 
3144 3144
 /*
3145 3145
  * call-seq:
3146  
- *     big << numeric   =>  integer
  3146
+ *     big << numeric   ->  integer
3147 3147
  *
3148 3148
  * Shifts big left _numeric_ positions (right if _numeric_ is negative).
3149 3149
  */
@@ -3207,7 +3207,7 @@ big_lshift(VALUE x, unsigned long shift)
3207 3207
 
3208 3208
 /*
3209 3209
  * call-seq:
3210  
- *     big >> numeric   =>  integer
  3210
+ *     big >> numeric   ->  integer
3211 3211
  *
3212 3212
  * Shifts big right _numeric_ positions (left if _numeric_ is negative).
3213 3213
  */
@@ -3351,7 +3351,7 @@ rb_big_aref(VALUE x, VALUE y)
3351 3351
 
3352 3352
 /*
3353 3353
  * call-seq:
3354  
- *   big.hash   => fixnum
  3354
+ *   big.hash   -> fixnum
3355 3355
  *
3356 3356
  * Compute a hash based on the value of _big_.
3357 3357
  */
12  class.c
@@ -698,7 +698,7 @@ rb_mod_included_modules(VALUE mod)
698 698
 
699 699
 /*
700 700
  *  call-seq:
701  
- *     mod.include?(module)    => true or false
  701
+ *     mod.include?(module)    -> true or false
702 702
  *
703 703
  *  Returns <code>true</code> if <i>module</i> is included in
704 704
  *  <i>mod</i> or one of <i>mod</i>'s ancestors.
@@ -863,7 +863,7 @@ class_instance_method_list(int argc, VALUE *argv, VALUE mod, int (*func) (ID, lo
863 863
 
864 864
 /*
865 865
  *  call-seq:
866  
- *     mod.instance_methods(include_super=true)   => array
  866
+ *     mod.instance_methods(include_super=true)   -> array
867 867
  *
868 868
  *  Returns an array containing the names of instance methods that is callable
869 869
  *  from outside in the receiver. For a module, these are the public methods;
@@ -896,7 +896,7 @@ rb_class_instance_methods(int argc, VALUE *argv, VALUE mod)
896 896
 
897 897
 /*
898 898
  *  call-seq:
899  
- *     mod.protected_instance_methods(include_super=true)   => array
  899
+ *     mod.protected_instance_methods(include_super=true)   -> array
900 900
  *
901 901
  *  Returns a list of the protected instance methods defined in
902 902
  *  <i>mod</i>. If the optional parameter is not <code>false</code>, the
@@ -911,7 +911,7 @@ rb_class_protected_instance_methods(int argc, VALUE *argv, VALUE mod)
911 911
 
912 912
 /*
913 913
  *  call-seq:
914  
- *     mod.private_instance_methods(include_super=true)    => array
  914
+ *     mod.private_instance_methods(include_super=true)    -> array
915 915
  *
916 916
  *  Returns a list of the private instance methods defined in
917 917
  *  <i>mod</i>. If the optional parameter is not <code>false</code>, the
@@ -934,7 +934,7 @@ rb_class_private_instance_methods(int argc, VALUE *argv, VALUE mod)
934 934
 
935 935
 /*
936 936
  *  call-seq:
937  
- *     mod.public_instance_methods(include_super=true)   => array
  937
+ *     mod.public_instance_methods(include_super=true)   -> array
938 938
  *
939 939
  *  Returns a list of the public instance methods defined in <i>mod</i>.
940 940
  *  If the optional parameter is not <code>false</code>, the methods of
@@ -949,7 +949,7 @@ rb_class_public_instance_methods(int argc, VALUE *argv, VALUE mod)
949 949
 
950 950
 /*
951 951
  *  call-seq:
952  
- *     obj.singleton_methods(all=true)    => array
  952
+ *     obj.singleton_methods(all=true)    -> array
953 953
  *
954 954
  *  Returns an array of the names of singleton methods for <i>obj</i>.
955 955
  *  If the optional <i>all</i> parameter is true, the list will include
12  compar.c
@@ -49,7 +49,7 @@ cmp_failed(void)
49 49
 
50 50
 /*
51 51
  *  call-seq:
52  
- *     obj == other    => true or false
  52
+ *     obj == other    -> true or false
53 53
  *
54 54
  *  Compares two objects based on the receiver's <code><=></code>
55 55
  *  method, returning true if it returns 0. Also returns true if
@@ -69,7 +69,7 @@ cmp_equal(VALUE x, VALUE y)
69 69
 
70 70
 /*
71 71
  *  call-seq:
72  
- *     obj > other    => true or false
  72
+ *     obj > other    -> true or false
73 73
  *
74 74
  *  Compares two objects based on the receiver's <code><=></code>
75 75
  *  method, returning true if it returns 1.
@@ -86,7 +86,7 @@ cmp_gt(VALUE x, VALUE y)
86 86
 
87 87
 /*
88 88
  *  call-seq:
89  
- *     obj >= other    => true or false
  89
+ *     obj >= other    -> true or false
90 90
  *
91 91
  *  Compares two objects based on the receiver's <code><=></code>
92 92
  *  method, returning true if it returns 0 or 1.
@@ -103,7 +103,7 @@ cmp_ge(VALUE x, VALUE y)
103 103
 
104 104
 /*
105 105
  *  call-seq:
106  
- *     obj < other    => true or false
  106
+ *     obj < other    -> true or false
107 107
  *
108 108
  *  Compares two objects based on the receiver's <code><=></code>
109 109
  *  method, returning true if it returns -1.
@@ -120,7 +120,7 @@ cmp_lt(VALUE x, VALUE y)
120 120
 
121 121
 /*
122 122
  *  call-seq:
123  
- *     obj <= other    => true or false
  123
+ *     obj <= other    -> true or false
124 124
  *
125 125
  *  Compares two objects based on the receiver's <code><=></code>
126 126
  *  method, returning true if it returns -1 or 0.
@@ -137,7 +137,7 @@ cmp_le(VALUE x, VALUE y)
137 137
 
138 138
 /*
139 139
  *  call-seq:
140  
- *     obj.between?(min, max)    => true or false
  140
+ *     obj.between?(min, max)    -> true or false
141 141
  *
142 142
  *  Returns <code>false</code> if <i>obj</i> <code><=></code>
143 143
  *  <i>min</i> is less than zero or if <i>anObject</i> <code><=></code>
2  cont.c
@@ -806,7 +806,7 @@ cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame)
806 806
 
807 807
 /*
808 808
  *  call-seq:
809  
- *     callcc {|cont| block }   =>  obj
  809
+ *     callcc {|cont| block }   ->  obj
810 810
  *
811 811
  *  Generates a <code>Continuation</code> object, which it passes to the
812 812
  *  associated block. Performing a <em>cont</em><code>.call</code> will
66  dir.c
@@ -428,8 +428,8 @@ dir_initialize(int argc, VALUE *argv, VALUE dir)
428 428
 
429 429
 /*
430 430
  *  call-seq:
431  
- *     Dir.open( string ) => aDir
432  
- *     Dir.open( string ) {| aDir | block } => anObject
  431
+ *     Dir.open( string ) -> aDir
  432
+ *     Dir.open( string ) {| aDir | block } -> anObject
433 433
  *
434 434
  *  With no block, <code>open</code> is a synonym for
435 435
  *  <code>Dir::new</code>. If a block is present, it is passed
@@ -474,7 +474,7 @@ dir_check(VALUE dir)
474 474
 
475 475
 /*
476 476
  *  call-seq:
477  
- *     dir.inspect => string
  477
+ *     dir.inspect -> string
478 478
  *
479 479
  *  Return a string describing this Dir object.
480 480
  */
@@ -493,7 +493,7 @@ dir_inspect(VALUE dir)
493 493
 
494 494
 /*
495 495
  *  call-seq:
496  
- *     dir.path => string or nil
  496
+ *     dir.path -> string or nil
497 497
  *
498 498
  *  Returns the path parameter passed to <em>dir</em>'s constructor.
499 499
  *
@@ -558,7 +558,7 @@ dir_path(VALUE dir)
558 558
 
559 559
 /*
560 560
  *  call-seq:
561  
- *     dir.read => string or nil
  561
+ *     dir.read -> string or nil
562 562
  *
563 563
  *  Reads the next entry from <em>dir</em> and returns it as a string.
564 564
  *  Returns <code>nil</code> at the end of the stream.
@@ -591,8 +591,8 @@ dir_read(VALUE dir)
591 591
 
592 592
 /*
593 593
  *  call-seq:
594  
- *     dir.each { |filename| block }  => dir
595  
- *     dir.each                       => an_enumerator
  594
+ *     dir.each { |filename| block }  -> dir
  595
+ *     dir.each                       -> an_enumerator
596 596
  *
597 597
  *  Calls the block once for each entry in this directory, passing the
598 598
  *  filename of each entry as a parameter to the block.
@@ -629,8 +629,8 @@ dir_each(VALUE dir)
629 629
 #ifdef HAVE_TELLDIR
630 630
 /*
631 631
  *  call-seq:
632  
- *     dir.pos => integer
633  
- *     dir.tell => integer
  632
+ *     dir.pos -> integer
  633
+ *     dir.tell -> integer
634 634
  *
635 635
  *  Returns the current position in <em>dir</em>. See also
636 636
  *  <code>Dir#seek</code>.
@@ -657,7 +657,7 @@ dir_tell(VALUE dir)
657 657
 #ifdef HAVE_SEEKDIR
658 658
 /*
659 659
  *  call-seq:
660  
- *     dir.seek( integer ) => dir
  660
+ *     dir.seek( integer ) -> dir
661 661
  *
662 662
  *  Seeks to a particular location in <em>dir</em>. <i>integer</i>
663 663
  *  must be a value returned by <code>Dir#tell</code>.
@@ -685,7 +685,7 @@ dir_seek(VALUE dir, VALUE pos)
685 685
 
686 686
 /*
687 687
  *  call-seq:
688  
- *     dir.pos( integer ) => integer
  688
+ *     dir.pos( integer ) -> integer
689 689
  *
690 690
  *  Synonym for <code>Dir#seek</code>, but returns the position
691 691
  *  parameter.
@@ -706,7 +706,7 @@ dir_set_pos(VALUE dir, VALUE pos)
706 706
 
707 707
 /*
708 708
  *  call-seq:
709  
- *     dir.rewind => dir
  709
+ *     dir.rewind -> dir
710 710
  *
711 711
  *  Repositions <em>dir</em> to the first entry.
712 712
  *
@@ -730,7 +730,7 @@ dir_rewind(VALUE dir)
730 730
 
731 731
 /*
732 732
  *  call-seq:
733  
- *     dir.close => nil
  733
+ *     dir.close -> nil
734 734
  *
735 735
  *  Closes the directory stream. Any further attempts to access
736 736
  *  <em>dir</em> will raise an <code>IOError</code>.
@@ -791,8 +791,8 @@ chdir_restore(struct chdir_data *args)
791 791
 
792 792
 /*
793 793
  *  call-seq:
794  
- *     Dir.chdir( [ string] ) => 0
795  
- *     Dir.chdir( [ string] ) {| path | block }  => anObject
  794
+ *     Dir.chdir( [ string] ) -> 0
  795
+ *     Dir.chdir( [ string] ) {| path | block }  -> anObject
796 796
  *
797 797
  *  Changes the current working directory of the process to the given
798 798
  *  string. When called without an argument, changes the directory to
@@ -882,8 +882,8 @@ rb_dir_getwd(void)
882 882
 
883 883
 /*
884 884
  *  call-seq:
885  
- *     Dir.getwd => string
886  
- *     Dir.pwd => string
  885
+ *     Dir.getwd -> string
  886
+ *     Dir.pwd -> string
887 887
  *
888 888
  *  Returns the path to the current working directory of this process as
889 889
  *  a string.
@@ -913,7 +913,7 @@ check_dirname(volatile VALUE *dir)
913 913
 #if defined(HAVE_CHROOT)
914 914
 /*
915 915
  *  call-seq:
916  
- *     Dir.chroot( string ) => 0
  916
+ *     Dir.chroot( string ) -> 0
917 917
  *
918 918
  *  Changes this process's idea of the file system root. Only a
919 919
  *  privileged process may make this call. Not available on all
@@ -937,7 +937,7 @@ dir_s_chroot(VALUE dir, VALUE path)
937 937
 
938 938
 /*
939 939
  *  call-seq:
940  
- *     Dir.mkdir( string [, integer] ) => 0
  940
+ *     Dir.mkdir( string [, integer] ) -> 0
941 941
  *
942 942
  *  Makes a new directory named by <i>string</i>, with permissions
943 943
  *  specified by the optional parameter <i>anInteger</i>. The
@@ -971,9 +971,9 @@ dir_s_mkdir(int argc, VALUE *argv, VALUE obj)
971 971
 
972 972
 /*
973 973
  *  call-seq:
974  
- *     Dir.delete( string ) => 0
975  
- *     Dir.rmdir( string ) => 0
976  
- *     Dir.unlink( string ) => 0
  974
+ *     Dir.delete( string ) -> 0
  975
+ *     Dir.rmdir( string ) -> 0
  976
+ *     Dir.unlink( string ) -> 0
977 977
  *
978 978
  *  Deletes the named directory. Raises a subclass of
979 979
  *  <code>SystemCallError</code> if the directory isn't empty.
@@ -1702,8 +1702,8 @@ dir_globs(long argc, VALUE *argv, int flags)
1702 1702
 
1703 1703
 /*
1704 1704
  *  call-seq:
1705  
- *     Dir[ array ]                 => array
1706  
- *     Dir[ string [, string ...] ] => array
  1705
+ *     Dir[ array ]                 -> array
  1706
+ *     Dir[ string [, string ...] ] -> array
1707 1707
  *
1708 1708
  *  Equivalent to calling
1709 1709
  *  <code>Dir.glob(</code><i>array,</i><code>0)</code> and
@@ -1721,8 +1721,8 @@ dir_s_aref(int argc, VALUE *argv, VALUE obj)
1721 1721
 
1722 1722
 /*
1723 1723
  *  call-seq:
1724  
- *     Dir.glob( pattern, [flags] ) => array
1725  
- *     Dir.glob( pattern, [flags] ) {| filename | block }  => nil
  1724
+ *     Dir.glob( pattern, [flags] ) -> array
  1725
+ *     Dir.glob( pattern, [flags] ) {| filename | block }  -> nil
1726 1726
  *
1727 1727
  *  Returns the filenames found by expanding <i>pattern</i> which is
1728 1728
  *  an +Array+ of the patterns or the pattern +String+, either as an
@@ -1822,8 +1822,8 @@ dir_open_dir(int argc, VALUE *argv)
1822 1822
 
1823 1823
 /*
1824 1824
  *  call-seq:
1825  
- *     Dir.foreach( dirname ) {| filename | block }  => nil
1826  
- *     Dir.foreach( dirname )                        => an_enumerator
  1825
+ *     Dir.foreach( dirname ) {| filename | block }  -> nil
  1826
+ *     Dir.foreach( dirname )                        -> an_enumerator
1827 1827
  *
1828 1828
  *  Calls the block once for each entry in the named directory, passing
1829 1829
  *  the filename of each entry as a parameter to the block.
@@ -1853,7 +1853,7 @@ dir_foreach(int argc, VALUE *argv, VALUE io)
1853 1853
 
1854 1854
 /*
1855 1855
  *  call-seq:
1856  
- *     Dir.entries( dirname ) => array
  1856
+ *     Dir.entries( dirname ) -> array
1857 1857
  *
1858 1858
  *  Returns an array containing all of the filenames in the given
1859 1859
  *  directory. Will raise a <code>SystemCallError</code> if the named
@@ -1873,8 +1873,8 @@ dir_entries(int argc, VALUE *argv, VALUE io)
1873 1873
 
1874 1874
 /*
1875 1875
  *  call-seq:
1876  
- *     File.fnmatch( pattern, path, [flags] ) => (true or false)
1877  
- *     File.fnmatch?( pattern, path, [flags] ) => (true or false)
  1876
+ *     File.fnmatch( pattern, path, [flags] ) -> (true or false)
  1877
+ *     File.fnmatch?( pattern, path, [flags] ) -> (true or false)
1878 1878
  *
1879 1879
  *  Returns true if <i>path</i> matches against <i>pattern</i> The
1880 1880
  *  pattern is not a regular expression; instead it follows rules
@@ -1978,8 +1978,8 @@ VALUE rb_home_dir(const char *user, VALUE result);
1978 1978
 
1979 1979
 /*
1980 1980
  *  call-seq:
1981  
- *    Dir.home()       => "/home/me"
1982  
- *    Dir.home("root") => "/root"
  1981
+ *    Dir.home()       -> "/home/me"
  1982
+ *    Dir.home("root") -> "/root"
1983 1983
  *
1984 1984
  *  Returns the home directory of the current user or the named user
1985 1985
  *  if given.
74  encoding.c
@@ -315,7 +315,7 @@ rb_enc_replicate(const char *name, rb_encoding *encoding)
315 315
 
316 316
 /*
317 317
  * call-seq:
318  
- *   enc.replicate(name) => encoding
  318
+ *   enc.replicate(name) -> encoding
319 319
  *
320 320
  * Returns a replicated encoding of _enc_ whose name is _name_.
321 321
  * The new encoding should have the same byte structure of _enc_.
@@ -381,7 +381,7 @@ rb_encdb_dummy(const char *name)
381 381
 
382 382
 /*
383 383
  * call-seq:
384  
- *   enc.dummy? => true or false
  384
+ *   enc.dummy? -> true or false
385 385
  *
386 386
  * Returns true for dummy encodings.
387 387
  * A dummy encoding is an encoding for which character handling is not properly
@@ -400,7 +400,7 @@ enc_dummy_p(VALUE enc)
400 400
 
401 401
 /*
402 402
  * call-seq:
403  
- *   enc.ascii_compatible? => true or false
  403
+ *   enc.ascii_compatible? -> true or false
404 404
  *
405 405
  * Returns whether ASCII-compatible or not.
406 406
  *
@@ -791,7 +791,7 @@ rb_enc_copy(VALUE obj1, VALUE obj2)
791 791
 
792 792
 /*
793 793
  *  call-seq:
794  
- *     obj.encoding   => encoding
  794
+ *     obj.encoding   -> encoding
795 795
  *
796 796
  *  Returns the Encoding object that represents the encoding of obj.
797 797
  */
@@ -905,7 +905,7 @@ rb_enc_tolower(int c, rb_encoding *enc)
905 905
 
906 906
 /*
907 907
  * call-seq:
908  
- *   enc.inspect => string
  908
+ *   enc.inspect -> string
909 909
  *
910 910
  * Returns a string which represents the encoding for programmers.
911 911
  *
@@ -924,11 +924,11 @@ enc_inspect(VALUE self)
924 924
 
925 925
 /*
926 926
  * call-seq:
927  
- *   enc.name => string
  927
+ *   enc.name -> string
928 928
  *
929 929
  * Returns the name of the encoding.
930 930
  *
931  
- *   Encoding::UTF_8.name       => "UTF-8"
  931
+ *   Encoding::UTF_8.name      #=> "UTF-8"
932 932
  */
933 933
 static VALUE
934 934
 enc_name(VALUE self)
@@ -951,11 +951,11 @@ enc_names_i(st_data_t name, st_data_t idx, st_data_t args)
951 951
 
952 952
 /*
953 953
  * call-seq:
954  
- *   enc.names => array
  954
+ *   enc.names -> array
955 955
  *
956 956
  * Returns the list of name and aliases of the encoding.
957 957
  *
958  
- *   Encoding::WINDOWS_31J.names => ["Windows-31J", "CP932", "csWindows31J"]
  958
+ *   Encoding::WINDOWS_31J.names  #=> ["Windows-31J", "CP932", "csWindows31J"]
959 959
  */
960 960
 static VALUE
961 961
 enc_names(VALUE self)
@@ -970,20 +970,20 @@ enc_names(VALUE self)
970 970
 
971 971
 /*
972 972
  * call-seq:
973  
- *   Encoding.list => [enc1, enc2, ...]
  973
+ *   Encoding.list -> [enc1, enc2, ...]
974 974
  *
975 975
  * Returns the list of loaded encodings.
976 976
  *
977 977
  *   Encoding.list
978  
- *   => [#<Encoding:ASCII-8BIT>, #<Encoding:UTF-8>,
979  
- *       #<Encoding:ISO-2022-JP (dummy)>]
  978
+ *   #=> [#<Encoding:ASCII-8BIT>, #<Encoding:UTF-8>,
  979
+ *         #<Encoding:ISO-2022-JP (dummy)>]
980 980
  *
981 981
  *   Encoding.find("US-ASCII")
982  
- *   => #<Encoding:US-ASCII>
  982
+ *   #=> #<Encoding:US-ASCII>
983 983
  *
984 984
  *   Encoding.list
985  
- *   => [#<Encoding:ASCII-8BIT>, #<Encoding:UTF-8>,
986  
- *       #<Encoding:US-ASCII>, #<Encoding:ISO-2022-JP (dummy)>]
  985
+ *   #=> [#<Encoding:ASCII-8BIT>, #<Encoding:UTF-8>,
  986
+ *         #<Encoding:US-ASCII>, #<Encoding:ISO-2022-JP (dummy)>]
987 987
  *
988 988
  */
989 989
 static VALUE
@@ -996,14 +996,14 @@ enc_list(VALUE klass)
996 996
 
997 997
 /*
998 998
  * call-seq:
999  
- *   Encoding.find(string) => enc
1000  
- *   Encoding.find(symbol) => enc
  999
+ *   Encoding.find(string) -> enc
  1000
+ *   Encoding.find(symbol) -> enc
1001 1001
  *
1002 1002
  * Search the encoding with specified <i>name</i>.
1003 1003
  * <i>name</i> should be a string or symbol.
1004 1004
  *
1005  
- *   Encoding.find("US-ASCII")  => #<Encoding:US-ASCII>
1006  
- *   Encoding.find(:Shift_JIS)  => #<Encoding:Shift_JIS>
  1005
+ *   Encoding.find("US-ASCII")  #=> #<Encoding:US-ASCII>
  1006
+ *   Encoding.find(:Shift_JIS)  #=> #<Encoding:Shift_JIS>
1007 1007
  *
1008 1008
  * Names which this method accept are encoding names and aliases
1009 1009
  * including following special aliases
@@ -1026,7 +1026,7 @@ enc_find(VALUE klass, VALUE enc)
1026 1026
 
1027 1027
 /*
1028 1028
  * call-seq:
1029  
- *   Encoding.compatible?(str1, str2) => enc or nil
  1029
+ *   Encoding.compatible?(str1, str2) -> enc or nil
1030 1030
  *
1031 1031
  * Checks the compatibility of two strings.
1032 1032
  * If they are compatible, means concatenatable,
@@ -1034,12 +1034,12 @@ enc_find(VALUE klass, VALUE enc)
1034 1034
  * If they are not compatible, nil is returned.
1035 1035
  *
1036 1036
  *   Encoding.compatible?("\xa1".force_encoding("iso-8859-1"), "b")
1037  
- *   => #<Encoding:ISO-8859-1>
  1037
+ *   #=> #<Encoding:ISO-8859-1>
1038 1038
  *
1039 1039
  *   Encoding.compatible?(
1040 1040
  *     "\xa1".force_encoding("iso-8859-1"),
1041 1041
  *     "\xa1\xa1".force_encoding("euc-jp"))
1042  
- *   => nil
  1042
+ *   #=> nil
1043 1043
  *
1044 1044
  */
1045 1045
 static VALUE
@@ -1226,7 +1226,7 @@ rb_enc_default_external(void)
1226 1226
 
1227 1227
 /*
1228 1228
  * call-seq:
1229  
- *   Encoding.default_external => enc
  1229
+ *   Encoding.default_external -> enc
1230 1230
  *
1231 1231
  * Returns default external encoding.
1232 1232
  *
@@ -1282,7 +1282,7 @@ rb_enc_default_internal(void)
1282 1282
 
1283 1283
 /*
1284 1284
  * call-seq:
1285  
- *   Encoding.default_internal => enc
  1285
+ *   Encoding.default_internal -> enc
1286 1286
  *
1287 1287
  * Returns default internal encoding.
1288 1288
  *
@@ -1318,21 +1318,21 @@ set_default_internal(VALUE klass, VALUE encoding)
1318 1318
 
1319 1319
 /*
1320 1320
  * call-seq:
1321  
- *   Encoding.locale_charmap => string
  1321
+ *   Encoding.locale_charmap -> string
1322 1322
  *
1323 1323
  * Returns the locale charmap name.
1324 1324
  *
1325 1325
  *   Debian GNU/Linux
1326 1326
  *     LANG=C
1327  
- *       Encoding.locale_charmap  => "ANSI_X3.4-1968"
  1327
+ *       Encoding.locale_charmap  #=> "ANSI_X3.4-1968"
1328 1328
  *     LANG=ja_JP.EUC-JP
1329  
- *       Encoding.locale_charmap  => "EUC-JP"
  1329
+ *       Encoding.locale_charmap  #=> "EUC-JP"
1330 1330
  *
1331 1331
  *   SunOS 5
1332 1332
  *     LANG=C
1333  
- *       Encoding.locale_charmap  => "646"
  1333
+ *       Encoding.locale_charmap  #=> "646"
1334 1334
  *     LANG=ja
1335  
- *       Encoding.locale_charmap  => "eucJP"
  1335
+ *       Encoding.locale_charmap  #=> "eucJP"
1336 1336
  *
1337 1337
  * The result is highly platform dependent.
1338 1338
  * So Encoding.find(Encoding.locale_charmap) may cause an error.
@@ -1426,15 +1426,15 @@ rb_enc_name_list_i(st_data_t name, st_data_t idx, st_data_t arg)
1426 1426
 
1427 1427
 /*
1428 1428
  * call-seq:
1429  
- *   Encoding.name_list => ["enc1", "enc2", ...]
  1429
+ *   Encoding.name_list -> ["enc1", "enc2", ...]
1430 1430
  *
1431 1431
  * Returns the list of available encoding names.
1432 1432
  *
1433 1433
  *   Encoding.name_list
1434  
- *   => ["US-ASCII", "ASCII-8BIT", "UTF-8",
1435  
- *       "ISO-8859-1", "Shift_JIS", "EUC-JP",
1436  
- *       "Windows-31J",
1437  
- *       "BINARY", "CP932", "eucJP"]
  1434
+ *   #=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
  1435
+ *         "ISO-8859-1", "Shift_JIS", "EUC-JP",
  1436
+ *         "Windows-31J",
  1437
+ *         "BINARY", "CP932", "eucJP"]
1438 1438
  *
1439 1439
  */
1440 1440
 
@@ -1473,13 +1473,13 @@ rb_enc_aliases_enc_i(st_data_t name, st_data_t orig, st_data_t arg)
1473 1473
 
1474 1474
 /*
1475 1475
  * call-seq:
1476  
- *   Encoding.aliases => {"alias1" => "orig1", "alias2" => "orig2", ...}
  1476
+ *   Encoding.aliases -> {"alias1" => "orig1", "alias2" => "orig2", ...}
1477 1477
  *
1478 1478
  * Returns the hash of available encoding alias and original encoding name.
1479 1479
  *
1480 1480
  *   Encoding.aliases
1481  
- *   => {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
1482  
- *       "SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"}
  1481
+ *   #=> {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
  1482
+ *         "SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"}
1483 1483
  *
1484 1484
  */
1485 1485
 
170  enum.c
@@ -56,8 +56,8 @@ grep_iter_i(VALUE i, VALUE args, int argc, VALUE *argv)
56 56
 
57 57
 /*
58 58
  *  call-seq:
59  
- *     enum.grep(pattern)                   => array
60  
- *     enum.grep(pattern) {| obj | block }  => array
  59
+ *     enum.grep(pattern)                  ->array
  60
+ *     enum.grep(pattern) {| obj | block } ->array
61 61
  *
62 62
  *  Returns an array of every element in <i>enum</i> for which
63 63
  *  <code>Pattern === element</code>. If the optional <em>block</em> is
@@ -121,9 +121,9 @@ count_all_i(VALUE i, VALUE memop, int argc, VALUE *argv)
121 121
 
122 122
 /*
123 123
  *  call-seq:
124  
- *     enum.count                   => int
125  
- *     enum.count(item)             => int
126  
- *     enum.count {| obj | block }  => int
  124
+ *     enum.count                  ->int
  125
+ *     enum.count(item)            ->int
  126
+ *     enum.count {| obj | block } ->int
127 127
  *
128 128
  *  Returns the number of items in <i>enum</i>, where #size is called
129 129
  *  if it responds to it, otherwise the items are counted through
@@ -132,9 +132,9 @@ count_all_i(VALUE i, VALUE memop, int argc, VALUE *argv)
132 132
  *  given, counts the number of elements yielding a true value.
133 133
  *
134 134
  *     ary = [1, 2, 4, 2]
135  
- *     ary.count             # => 4
136  
- *     ary.count(2)          # => 2
137  
- *     ary.count{|x|x%2==0}  # => 3
  135
+ *     ary.count             #=> 4
  136
+ *     ary.count(2)          #=> 2
  137
+ *     ary.count{|x|x%2==0}  #=> 3
138 138
  *
139 139
  */
140 140
 
@@ -179,10 +179,10 @@ find_i(VALUE i, VALUE *memo, int argc, VALUE *argv)
179 179
 
180 180
 /*
181 181
  *  call-seq:
182  
- *     enum.detect(ifnone = nil) {| obj | block }  => obj or nil
183  
- *     enum.find(ifnone = nil)   {| obj | block }  => obj or nil
184  
- *     enum.detect(ifnone = nil)                   => an_enumerator
185  
- *     enum.find(ifnone = nil)                     => an_enumerator
  182
+ *     enum.detect(ifnone = nil) {| obj | block } ->obj or nil
  183
+ *     enum.find(ifnone = nil)   {| obj | block } ->obj or nil
  184
+ *     enum.detect(ifnone = nil)                  ->an_enumerator
  185
+ *     enum.find(ifnone = nil)                    ->an_enumerator
186 186
  *
187 187
  *  Passes each entry in <i>enum</i> to <em>block</em>. Returns the
188 188
  *  first for which <em>block</em> is not false.  If no
@@ -244,9 +244,9 @@ find_index_iter_i(VALUE i, VALUE memop, int argc, VALUE *argv)
244 244
 
245 245
 /*
246 246
  *  call-seq:
247  
- *     enum.find_index(value)            => int or nil
248  
- *     enum.find_index {| obj | block }  => int or nil
249  
- *     enum.find_index                   => an_enumerator
  247
+ *     enum.find_index(value)           ->int or nil
  248
+ *     enum.find_index {| obj | block } ->int or nil
  249
+ *     enum.find_index                  ->an_enumerator
250 250
  *
251 251
  *  Compares each entry in <i>enum</i> with <em>value</em> or passes
252 252
  *  to <em>block</em>.  Returns the index for the first for which the
@@ -298,10 +298,10 @@ find_all_i(VALUE i, VALUE ary, int argc, VALUE *argv)
298 298
 
299 299
 /*
300 300
  *  call-seq:
301  
- *     enum.find_all {| obj | block }  => array
302  
- *     enum.select   {| obj | block }  => array
303  
- *     enum.find_all                   => an_enumerator
304  
- *     enum.select                     => an_enumerator
  301
+ *     enum.find_all {| obj | block } ->array
  302
+ *     enum.select   {| obj | block } ->array
  303
+ *     enum.find_all                  ->an_enumerator
  304
+ *     enum.select                    ->an_enumerator
305 305
  *
306 306
  *  Returns an array containing all elements of <i>enum</i> for which
307 307
  *  <em>block</em> is not <code>false</code> (see also
@@ -340,8 +340,8 @@ reject_i(VALUE i, VALUE ary, int argc, VALUE *argv)
340 340
 
341 341
 /*
342 342
  *  call-seq:
343  
- *     enum.reject {| obj | block }  => array
344  
- *     enum.reject                   => an_enumerator
  343
+ *     enum.reject {| obj | block } ->array
  344
+ *     enum.reject                  ->an_enumerator
345 345
  *
346 346
  *  Returns an array for all elements of <i>enum</i> for which
347 347
  *  <em>block</em> is false (see also <code>Enumerable#find_all</code>).
@@ -384,10 +384,10 @@ collect_all(VALUE i, VALUE ary, int argc, VALUE *argv)
384 384
 
385 385
 /*
386 386
  *  call-seq:
387  
- *     enum.collect {| obj | block }  => array
388  
- *     enum.map     {| obj | block }  => array
389  
- *     enum.collect                   => an_enumerator
390  
- *     enum.map                       => an_enumerator
  387
+ *     enum.collect {| obj | block } ->array
  388
+ *     enum.map     {| obj | block } ->array
  389
+ *     enum.collect                  ->an_enumerator
  390
+ *     enum.map                      ->an_enumerator
391 391
  *
392 392
  *  Returns a new array with the results of running <em>block</em> once
393 393
  *  for every element in <i>enum</i>.
@@ -431,10 +431,10 @@ flat_map_i(VALUE i, VALUE ary, int argc, VALUE *argv)
431 431
 
432 432
 /*
433 433
  *  call-seq:
434  
- *     enum.flat_map       {| obj | block }  => array
435  
- *     enum.collect_concat {| obj | block }  => array
436  
- *     enum.flat_map                         => an_enumerator
437  
- *     enum.collect_concat                   => an_enumerator
  434
+ *     enum.flat_map       {| obj | block } ->array
  435
+ *     enum.collect_concat {| obj | block } ->array
  436
+ *     enum.flat_map                        ->an_enumerator
  437
+ *     enum.collect_concat                  ->an_enumerator
438 438
  *
439 439
  *  Returns a new array with the concatenated results of running
440 440
  *  <em>block</em> once for every element in <i>enum</i>.
@@ -460,8 +460,8 @@ enum_flat_map(VALUE obj)
460 460
 
461 461
 /*
462 462
  *  call-seq:
463  
- *     enum.to_a      =>    array
464  
- *     enum.entries   =>    array
  463
+ *     enum.to_a     ->   array
  464
+ *     enum.entries  ->   array
465 465
  *
466 466
  *  Returns an array containing the items in <i>enum</i>.
467 467
  *
@@ -513,15 +513,15 @@ inject_op_i(VALUE i, VALUE p, int argc, VALUE *argv)
513 513
 
514 514
 /*
515 515
  *  call-seq:
516  
- *     enum.inject(initial, sym) => obj
517  
- *     enum.inject(sym)          => obj
518  
- *     enum.inject(initial) {| memo, obj | block }  => obj
519  
- *     enum.inject          {| memo, obj | block }  => obj
  516
+ *     enum.inject(initial, sym)->obj
  517
+ *     enum.inject(sym)         ->obj
  518
+ *     enum.inject(initial) {| memo, obj | block } ->obj
  519
+ *     enum.inject          {| memo, obj | block } ->obj
520 520
  *
521  
- *     enum.reduce(initial, sym) => obj
522  
- *     enum.reduce(sym)          => obj
523  
- *     enum.reduce(initial) {| memo, obj | block }  => obj
524  
- *     enum.reduce          {| memo, obj | block }  => obj
  521
+ *     enum.reduce(initial, sym)->obj
  522
+ *     enum.reduce(sym)         ->obj
  523
+ *     enum.reduce(initial) {| memo, obj | block } ->obj
  524
+ *     enum.reduce          {| memo, obj | block } ->obj
525 525
  *
526 526
  *  Combines all elements of <i>enum</i> by applying a binary
527 527
  *  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)
603 603
 
604 604
 /*
605 605
  *  call-seq:
606  
- *     enum.partition {| obj | block }  => [ true_array, false_array ]
607  
- *     enum.partition                   => an_enumerator
  606
+ *     enum.partition {| obj | block } ->[ true_array, false_array ]
  607
+ *     enum.partition                  ->an_enumerator
608 608
  *
609 609
  *  Returns two arrays, the first containing the elements of
610 610
  *  <i>enum</i> for which the block evaluates to true, the second
@@ -652,8 +652,8 @@ group_by_i(VALUE i, VALUE hash, int argc, VALUE *argv)
652 652
 
653 653
 /*
654 654
  *  call-seq:
655  
- *     enum.group_by {| obj | block }  => a_hash
656  
- *     enum.group_by                   => an_enumerator
  655
+ *     enum.group_by {| obj | block } ->a_hash
  656
+ *     enum.group_by                  ->an_enumerator
657 657
  *
658 658
  *  Returns a hash, which keys are evaluated result from the
659 659
  *  block, and values are arrays of elements in <i>enum</i>
@@ -740,8 +740,8 @@ enum_first(int argc, VALUE *argv, VALUE obj)
740 740
 
741 741
 /*
742 742
  *  call-seq:
743  
- *     enum.sort                     => array
744  
- *     enum.sort {| a, b | block }   => array
  743
+ *     enum.sort                    ->array
  744
+ *     enum.sort {| a, b | block }  ->array
745 745
  *
746 746
  *  Returns an array containing the items in <i>enum</i> sorted,
747 747
  *  either according to their own <code><=></code> method, or by using
@@ -792,8 +792,8 @@ sort_by_cmp(const void *ap, const void *bp, void *data)
792 792
 
793 793
 /*
794 794
  *  call-seq:
795  
- *     enum.sort_by {| obj | block }    => array
796  
- *     enum.sort_by                     => an_enumerator
  795
+ *     enum.sort_by {| obj | block }   ->array
  796
+ *     enum.sort_by                    ->an_enumerator
797 797
  *
798 798
  *  Sorts <i>enum</i> using a set of keys generated by mapping the
799 799
  *  values in <i>enum</i> through the given block.
@@ -924,7 +924,7 @@ DEFINE_ENUMFUNCS(all)
924 924
 
925 925
 /*
926 926
  *  call-seq:
927  
- *     enum.all? [{|obj| block } ]   => true or false
  927
+ *     enum.all? [{|obj| block } ]  ->true or false
928 928
  *
929 929
  *  Passes each element of the collection to the given block. The method
930 930
  *  returns <code>true</code> if the block never returns
@@ -959,7 +959,7 @@ DEFINE_ENUMFUNCS(any)
959 959
 
960 960
 /*
961 961
  *  call-seq:
962  
- *     enum.any? [{|obj| block } ]   => true or false
  962
+ *     enum.any? [{|obj| block } ]  ->true or false
963 963
  *
964 964
  *  Passes each element of the collection to the given block. The method
965 965
  *  returns <code>true</code> if the block ever returns a value other
@@ -1000,7 +1000,7 @@ DEFINE_ENUMFUNCS(one)
1000 1000
 
1001 1001
 /*
1002 1002
  *  call-seq:
1003  
- *     enum.one? [{|obj| block }]   => true or false
  1003
+ *     enum.one? [{|obj| block }]  ->true or false
1004 1004
  *
1005 1005
  *  Passes each element of the collection to the given block. The method
1006 1006
  *  returns <code>true</code> if the block returns <code>true</code>
@@ -1037,7 +1037,7 @@ DEFINE_ENUMFUNCS(none)
1037 1037
 
1038 1038
 /*
1039 1039
  *  call-seq:
1040  
- *     enum.none? [{|obj| block }]   => true or false
  1040
+ *     enum.none? [{|obj| block }]  ->true or false
1041 1041
  *
1042 1042
  *  Passes each element of the collection to the given block. The method
1043 1043
  *  returns <code>true</code> if the block never returns <code>true</code>
@@ -1100,8 +1100,8 @@ min_ii(VALUE i, VALUE *memo, int argc, VALUE *argv)
1100 1100
 
1101 1101
 /*
1102 1102
  *  call-seq:
1103  
- *     enum.min                    => obj
1104  
- *     enum.min {| a,b | block }   => obj
  1103
+ *     enum.min                   ->obj
  1104
+ *     enum.min {| a,b | block }  ->obj
1105 1105
  *
1106 1106
  *  Returns the object in <i>enum</i> with the minimum value. The
1107 1107
  *  first form assumes all objects implement <code>Comparable</code>;
@@ -1167,8 +1167,8 @@ max_ii(VALUE i, VALUE *memo, int argc, VALUE *argv)
1167 1167
 
1168 1168
 /*
1169 1169
  *  call-seq:
1170  
- *     enum.max                   => obj
1171  
- *     enum.max {|a,b| block }    => obj
  1170
+ *     enum.max                  ->obj
  1171
+ *     enum.max {|a,b| block }   ->obj
1172 1172
  *
1173 1173
  *  Returns the object in _enum_ with the maximum value. The
1174 1174
  *  first form assumes all objects implement <code>Comparable</code>;
@@ -1306,8 +1306,8 @@ minmax_ii(VALUE i, VALUE _memo, int argc, VALUE *argv)
1306 1306
 
1307 1307
 /*
1308 1308
  *  call-seq:
1309  
- *     enum.minmax                   => [min,max]
1310  
- *     enum.minmax {|a,b| block }    => [min,max]
  1309
+ *     enum.minmax                  ->[min,max]
  1310
+ *     enum.minmax {|a,b| block }   ->[min,max]
1311 1311
  *
1312 1312
  *  Returns two elements array which contains the minimum and the
1313 1313
  *  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)
1365 1365
 
1366 1366
 /*
1367 1367
  *  call-seq:
1368  
- *     enum.min_by {|obj| block }   => obj
1369  
- *     enum.min_by                  => an_enumerator
  1368
+ *     enum.min_by {|obj| block }  ->obj
  1369
+ *     enum.min_by                 ->an_enumerator
1370 1370
  *
1371 1371
  *  Returns the object in <i>enum</i> that gives the minimum
1372 1372
  *  value from the given block.
@@ -1411,8 +1411,8 @@ max_by_i(VALUE i, VALUE *memo, int argc, VALUE *argv)
1411 1411
 
1412 1412
 /*
1413 1413
  *  call-seq:
1414  
- *     enum.max_by {|obj| block }   => obj
1415  
- *     enum.max_by                  => an_enumerator
  1414
+ *     enum.max_by {|obj| block }  ->obj
  1415
+ *     enum.max_by                 ->an_enumerator
1416 1416
  *
1417 1417
  *  Returns the object in <i>enum</i> that gives the maximum
1418 1418
  *  value from the given block.
@@ -1508,8 +1508,8 @@ minmax_by_i(VALUE i, VALUE _memo, int argc, VALUE *argv)
1508 1508
 
1509 1509
 /*
1510 1510
  *  call-seq:
1511  
- *     enum.minmax_by {|obj| block }   => [min, max]
1512  
- *     enum.minmax_by                  => an_enumerator
  1511
+ *     enum.minmax_by {|obj| block }  ->[min, max]
  1512
+ *     enum.minmax_by                 ->an_enumerator
1513 1513
  *
1514 1514
  *  Returns two elements array array containing the objects in
1515 1515
  *  <i>enum</i> that gives the minimum and maximum values respectively
@@ -1552,8 +1552,8 @@ member_i(VALUE iter, VALUE *memo, int argc, VALUE *argv)
1552 1552
 
1553 1553
 /*
1554 1554
  *  call-seq:
1555  
- *     enum.include?(obj)     => true or false
1556  
- *     enum.member?(obj)      => true or false
  1555
+ *     enum.include?(obj)    ->true or false
  1556
+ *     enum.member?(obj)     ->true or false
1557 1557
  *
1558 1558
  *  Returns <code>true</code> if any member of <i>enum</i> equals
1559 1559
  *  <i>obj</i>. Equality is tested using <code>==</code>.
@@ -1653,8 +1653,8 @@ each_val_i(VALUE i, VALUE p, int argc, VALUE *argv)
1653 1653
 
1654 1654
 /*
1655 1655
  *  call-seq:
1656  
- *     enum.each_entry {|obj| block}  => enum
1657  
- *     enum.each_entry                => an_enumerator
  1656
+ *     enum.each_entry {|obj| block} ->enum
  1657
+ *     enum.each_entry               ->an_enumerator
1658 1658
  *
1659 1659
  *  Calls <i>block</i> once for each element in +self+, passing that
1660 1660
  *  element as a parameter, converting multiple values from yield to an
@@ -1812,7 +1812,7 @@ each_with_object_i(VALUE i, VALUE memo, int argc, VALUE *argv)
1812 1812
  *
1813 1813
  *  e.g.:
1814 1814
  *      evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
1815  
- *      # => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
  1815
+ *      #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
1816 1816
  *
1817 1817
  */
1818 1818
 static VALUE
@@ -1904,8 +1904,8 @@ zip_i(VALUE val, NODE *memo, int argc, VALUE *argv)
1904 1904
 
1905 1905
 /*
1906 1906
  *  call-seq:
1907  
- *     enum.zip(arg, ...)                   => an_enumerator
1908  
- *     enum.zip(arg, ...) {|arr| block }    => nil
  1907
+ *     enum.zip(arg, ...)                  ->an_enumerator
  1908
+ *     enum.zip(arg, ...) {|arr| block }   ->nil
1909 1909
  *
1910 1910
  *  Takes one element from <i>enum</i> and merges corresponding
1911 1911
  *  elements from each <i>args</i>.  This generates a sequence of
@@ -1970,12 +1970,12 @@ take_i(VALUE i, VALUE *arg, int argc, VALUE *argv)
1970 1970
 
1971 1971
 /*
1972 1972
  *  call-seq:
1973  
- *     enum.take(n)               => array
  1973
+ *     enum.take(n)              ->array
1974 1974
  *
1975 1975
  *  Returns first n elements from <i>enum</i>.
1976 1976
  *
1977 1977
  *     a = [1, 2, 3, 4, 5, 0]
1978  
- *     a.take(3)             # => [1, 2, 3]
  1978
+ *     a.take(3)             #=> [1, 2, 3]
1979 1979
  *
1980 1980
  */
1981 1981
 
@@ -2007,8 +2007,8 @@ take_while_i(VALUE i, VALUE *ary, int argc, VALUE *argv)
2007 2007
 
2008 2008
 /*
2009 2009
  *  call-seq: