1## 2# Enumerable 3# 4module Enumerable 5 ## 6 # call-seq: 7 # enum.drop(n) -> array 8 # 9 # Drops first n elements from <i>enum</i>, and returns rest elements 10 # in an array. 11 # 12 # a = [1, 2, 3, 4, 5, 0] 13 # a.drop(3) #=> [4, 5, 0] 14 15 def drop(n) 16 n = n.__to_int 17 raise ArgumentError, "attempt to drop negative size" if n < 0 18 19 ary = [] 20 self.each {|*val| n == 0 ? ary << val.__svalue : n -= 1 } 21 ary 22 end 23 24 ## 25 # call-seq: 26 # enum.drop_while {|arr| block } -> array 27 # enum.drop_while -> an_enumerator 28 # 29 # Drops elements up to, but not including, the first element for 30 # which the block returns +nil+ or +false+ and returns an array 31 # containing the remaining elements. 32 # 33 # If no block is given, an enumerator is returned instead. 34 # 35 # a = [1, 2, 3, 4, 5, 0] 36 # a.drop_while {|i| i < 3 } #=> [3, 4, 5, 0] 37 38 def drop_while(&block) 39 return to_enum :drop_while unless block 40 41 ary, state = [], false 42 self.each do |*val| 43 state = true if !state and !block.call(*val) 44 ary << val.__svalue if state 45 end 46 ary 47 end 48 49 ## 50 # call-seq: 51 # enum.take(n) -> array 52 # 53 # Returns first n elements from <i>enum</i>. 54 # 55 # a = [1, 2, 3, 4, 5, 0] 56 # a.take(3) #=> [1, 2, 3] 57 58 def take(n) 59 n = n.__to_int 60 i = n.to_i 61 raise ArgumentError, "attempt to take negative size" if i < 0 62 ary = [] 63 return ary if i == 0 64 self.each do |*val| 65 ary << val.__svalue 66 i -= 1 67 break if i == 0 68 end 69 ary 70 end 71 72 ## 73 # call-seq: 74 # enum.take_while {|arr| block } -> array 75 # enum.take_while -> an_enumerator 76 # 77 # Passes elements to the block until the block returns +nil+ or +false+, 78 # then stops iterating and returns an array of all prior elements. 79 # 80 # If no block is given, an enumerator is returned instead. 81 # 82 # a = [1, 2, 3, 4, 5, 0] 83 # a.take_while {|i| i < 3 } #=> [1, 2] 84 # 85 def take_while(&block) 86 return to_enum :take_while unless block 87 88 ary = [] 89 self.each do |*val| 90 return ary unless block.call(*val) 91 ary << val.__svalue 92 end 93 ary 94 end 95 96 ## 97 # Iterates the given block for each array of consecutive <n> 98 # elements. 99 # 100 # @return [nil] 101 # 102 # @example 103 # (1..10).each_cons(3) {|a| p a} 104 # # outputs below 105 # [1, 2, 3] 106 # [2, 3, 4] 107 # [3, 4, 5] 108 # [4, 5, 6] 109 # [5, 6, 7] 110 # [6, 7, 8] 111 # [7, 8, 9] 112 # [8, 9, 10] 113 114 def each_cons(n, &block) 115 n = n.__to_int 116 raise ArgumentError, "invalid size" if n <= 0 117 118 return to_enum(:each_cons,n) unless block 119 ary = [] 120 n = n.to_i 121 self.each do |*val| 122 ary.shift if ary.size == n 123 ary << val.__svalue 124 block.call(ary.dup) if ary.size == n 125 end 126 nil 127 end 128 129 ## 130 # Iterates the given block for each slice of <n> elements. 131 # 132 # @return [nil] 133 # 134 # @example 135 # (1..10).each_slice(3) {|a| p a} 136 # # outputs below 137 # [1, 2, 3] 138 # [4, 5, 6] 139 # [7, 8, 9] 140 # [10] 141 142 def each_slice(n, &block) 143 n = n.__to_int 144 raise ArgumentError, "invalid slice size" if n <= 0 145 146 return to_enum(:each_slice,n) unless block 147 ary = [] 148 n = n.to_i 149 self.each do |*val| 150 ary << val.__svalue 151 if ary.size == n 152 block.call(ary) 153 ary = [] 154 end 155 end 156 block.call(ary) unless ary.empty? 157 nil 158 end 159 160 ## 161 # call-seq: 162 # enum.group_by {| obj | block } -> a_hash 163 # enum.group_by -> an_enumerator 164 # 165 # Returns a hash, which keys are evaluated result from the 166 # block, and values are arrays of elements in <i>enum</i> 167 # corresponding to the key. 168 # 169 # (1..6).group_by {|i| i%3} #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]} 170 # 171 def group_by(&block) 172 return to_enum :group_by unless block 173 174 h = {} 175 self.each do |*val| 176 key = block.call(*val) 177 sv = val.__svalue 178 h.key?(key) ? (h[key] << sv) : (h[key] = [sv]) 179 end 180 h 181 end 182 183 ## 184 # call-seq: 185 # enum.sort_by { |obj| block } -> array 186 # enum.sort_by -> an_enumerator 187 # 188 # Sorts <i>enum</i> using a set of keys generated by mapping the 189 # values in <i>enum</i> through the given block. 190 # 191 # If no block is given, an enumerator is returned instead. 192 193 def sort_by(&block) 194 return to_enum :sort_by unless block 195 196 ary = [] 197 orig = [] 198 self.each_with_index{|e, i| 199 orig.push(e) 200 ary.push([block.call(e), i]) 201 } 202 if ary.size > 1 203 ary.sort! 204 end 205 ary.collect{|e,i| orig[i]} 206 end 207 208 ## 209 # call-seq: 210 # enum.first -> obj or nil 211 # enum.first(n) -> an_array 212 # 213 # Returns the first element, or the first +n+ elements, of the enumerable. 214 # If the enumerable is empty, the first form returns <code>nil</code>, and the 215 # second form returns an empty array. 216 def first(*args) 217 case args.length 218 when 0 219 self.each do |*val| 220 return val.__svalue 221 end 222 return nil 223 when 1 224 i = args[0].__to_int 225 raise ArgumentError, "attempt to take negative size" if i < 0 226 ary = [] 227 return ary if i == 0 228 self.each do |*val| 229 ary << val.__svalue 230 i -= 1 231 break if i == 0 232 end 233 ary 234 else 235 raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)" 236 end 237 end 238 239 ## 240 # call-seq: 241 # enum.count -> int 242 # enum.count(item) -> int 243 # enum.count { |obj| block } -> int 244 # 245 # Returns the number of items in +enum+ through enumeration. 246 # If an argument is given, the number of items in +enum+ that 247 # are equal to +item+ are counted. If a block is given, it 248 # counts the number of elements yielding a true value. 249 def count(v=NONE, &block) 250 count = 0 251 if block 252 self.each do |*val| 253 count += 1 if block.call(*val) 254 end 255 else 256 if v == NONE 257 self.each { count += 1 } 258 else 259 self.each do |*val| 260 count += 1 if val.__svalue == v 261 end 262 end 263 end 264 count 265 end 266 267 ## 268 # call-seq: 269 # enum.flat_map { |obj| block } -> array 270 # enum.collect_concat { |obj| block } -> array 271 # enum.flat_map -> an_enumerator 272 # enum.collect_concat -> an_enumerator 273 # 274 # Returns a new array with the concatenated results of running 275 # <em>block</em> once for every element in <i>enum</i>. 276 # 277 # If no block is given, an enumerator is returned instead. 278 # 279 # [1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4] 280 # [[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100] 281 def flat_map(&block) 282 return to_enum :flat_map unless block 283 284 ary = [] 285 self.each do |*e| 286 e2 = block.call(*e) 287 if e2.respond_to? :each 288 e2.each {|e3| ary.push(e3) } 289 else 290 ary.push(e2) 291 end 292 end 293 ary 294 end 295 alias collect_concat flat_map 296 297 ## 298 # call-seq: 299 # enum.max_by {|obj| block } -> obj 300 # enum.max_by -> an_enumerator 301 # 302 # Returns the object in <i>enum</i> that gives the maximum 303 # value from the given block. 304 # 305 # If no block is given, an enumerator is returned instead. 306 # 307 # %w[albatross dog horse].max_by {|x| x.length } #=> "albatross" 308 309 def max_by(&block) 310 return to_enum :max_by unless block 311 312 first = true 313 max = nil 314 max_cmp = nil 315 316 self.each do |*val| 317 if first 318 max = val.__svalue 319 max_cmp = block.call(*val) 320 first = false 321 else 322 if (cmp = block.call(*val)) > max_cmp 323 max = val.__svalue 324 max_cmp = cmp 325 end 326 end 327 end 328 max 329 end 330 331 ## 332 # call-seq: 333 # enum.min_by {|obj| block } -> obj 334 # enum.min_by -> an_enumerator 335 # 336 # Returns the object in <i>enum</i> that gives the minimum 337 # value from the given block. 338 # 339 # If no block is given, an enumerator is returned instead. 340 # 341 # %w[albatross dog horse].min_by {|x| x.length } #=> "dog" 342 343 def min_by(&block) 344 return to_enum :min_by unless block 345 346 first = true 347 min = nil 348 min_cmp = nil 349 350 self.each do |*val| 351 if first 352 min = val.__svalue 353 min_cmp = block.call(*val) 354 first = false 355 else 356 if (cmp = block.call(*val)) < min_cmp 357 min = val.__svalue 358 min_cmp = cmp 359 end 360 end 361 end 362 min 363 end 364 365 ## 366 # call-seq: 367 # enum.minmax -> [min, max] 368 # enum.minmax { |a, b| block } -> [min, max] 369 # 370 # Returns two elements array which contains the minimum and the 371 # maximum value in the enumerable. The first form assumes all 372 # objects implement <code>Comparable</code>; the second uses the 373 # block to return <em>a <=> b</em>. 374 # 375 # a = %w(albatross dog horse) 376 # a.minmax #=> ["albatross", "horse"] 377 # a.minmax { |a, b| a.length <=> b.length } #=> ["dog", "albatross"] 378 379 def minmax(&block) 380 max = nil 381 min = nil 382 first = true 383 384 self.each do |*val| 385 if first 386 val = val.__svalue 387 max = val 388 min = val 389 first = false 390 else 391 val = val.__svalue 392 if block 393 max = val if block.call(val, max) > 0 394 min = val if block.call(val, min) < 0 395 else 396 max = val if (val <=> max) > 0 397 min = val if (val <=> min) < 0 398 end 399 end 400 end 401 [min, max] 402 end 403 404 ## 405 # call-seq: 406 # enum.minmax_by { |obj| block } -> [min, max] 407 # enum.minmax_by -> an_enumerator 408 # 409 # Returns a two element array containing the objects in 410 # <i>enum</i> that correspond to the minimum and maximum values respectively 411 # from the given block. 412 # 413 # If no block is given, an enumerator is returned instead. 414 # 415 # %w(albatross dog horse).minmax_by { |x| x.length } #=> ["dog", "albatross"] 416 417 def minmax_by(&block) 418 return to_enum :minmax_by unless block 419 420 max = nil 421 max_cmp = nil 422 min = nil 423 min_cmp = nil 424 first = true 425 426 self.each do |*val| 427 if first 428 max = min = val.__svalue 429 max_cmp = min_cmp = block.call(*val) 430 first = false 431 else 432 if (cmp = block.call(*val)) > max_cmp 433 max = val.__svalue 434 max_cmp = cmp 435 end 436 if (cmp = block.call(*val)) < min_cmp 437 min = val.__svalue 438 min_cmp = cmp 439 end 440 end 441 end 442 [min, max] 443 end 444 445 ## 446 # call-seq: 447 # enum.none? [{ |obj| block }] -> true or false 448 # enum.none?(pattern) -> true or false 449 # 450 # Passes each element of the collection to the given block. The method 451 # returns <code>true</code> if the block never returns <code>true</code> 452 # for all elements. If the block is not given, <code>none?</code> will return 453 # <code>true</code> only if none of the collection members is true. 454 # 455 # If a pattern is supplied instead, the method returns whether 456 # <code>pattern === element</code> for none of the collection members. 457 # 458 # %w(ant bear cat).none? { |word| word.length == 5 } #=> true 459 # %w(ant bear cat).none? { |word| word.length >= 4 } #=> false 460 # %w{ant bear cat}.none?(/d/) #=> true 461 # [1, 3.14, 42].none?(Float) #=> false 462 # [].none? #=> true 463 # [nil, false].none? #=> true 464 # [nil, true].none? #=> false 465 466 def none?(pat=NONE, &block) 467 if pat != NONE 468 self.each do |*val| 469 return false if pat === val.__svalue 470 end 471 elsif block 472 self.each do |*val| 473 return false if block.call(*val) 474 end 475 else 476 self.each do |*val| 477 return false if val.__svalue 478 end 479 end 480 true 481 end 482 483 ## 484 # call-seq: 485 # enum.one? [{ |obj| block }] -> true or false 486 # enum.one?(pattern) -> true or false 487 # 488 # Passes each element of the collection to the given block. The method 489 # returns <code>true</code> if the block returns <code>true</code> 490 # exactly once. If the block is not given, <code>one?</code> will return 491 # <code>true</code> only if exactly one of the collection members is 492 # true. 493 # 494 # If a pattern is supplied instead, the method returns whether 495 # <code>pattern === element</code> for exactly one collection member. 496 # 497 # %w(ant bear cat).one? { |word| word.length == 4 } #=> true 498 # %w(ant bear cat).one? { |word| word.length > 4 } #=> false 499 # %w(ant bear cat).one? { |word| word.length < 4 } #=> false 500 # %w{ant bear cat}.one?(/t/) #=> false 501 # [nil, true, 99].one? #=> false 502 # [nil, true, false].one? #=> true 503 # [ nil, true, 99 ].one?(Integer) #=> true 504 # [].one? #=> false 505 506 def one?(pat=NONE, &block) 507 count = 0 508 if pat!=NONE 509 self.each do |*val| 510 count += 1 if pat === val.__svalue 511 return false if count > 1 512 end 513 elsif block 514 self.each do |*val| 515 count += 1 if block.call(*val) 516 return false if count > 1 517 end 518 else 519 self.each do |*val| 520 count += 1 if val.__svalue 521 return false if count > 1 522 end 523 end 524 525 count == 1 ? true : false 526 end 527 528 # ISO 15.3.2.2.1 529 # call-seq: 530 # enum.all? [{ |obj| block } ] -> true or false 531 # enum.all?(pattern) -> true or false 532 # 533 # Passes each element of the collection to the given block. The method 534 # returns <code>true</code> if the block never returns 535 # <code>false</code> or <code>nil</code>. If the block is not given, 536 # Ruby adds an implicit block of <code>{ |obj| obj }</code> which will 537 # cause #all? to return +true+ when none of the collection members are 538 # +false+ or +nil+. 539 # 540 # If a pattern is supplied instead, the method returns whether 541 # <code>pattern === element</code> for every collection member. 542 # 543 # %w[ant bear cat].all? { |word| word.length >= 3 } #=> true 544 # %w[ant bear cat].all? { |word| word.length >= 4 } #=> false 545 # %w[ant bear cat].all?(/t/) #=> false 546 # [1, 2i, 3.14].all?(Numeric) #=> true 547 # [nil, true, 99].all? #=> false 548 # 549 def all?(pat=NONE, &block) 550 if pat != NONE 551 self.each{|*val| return false unless pat === val.__svalue} 552 elsif block 553 self.each{|*val| return false unless block.call(*val)} 554 else 555 self.each{|*val| return false unless val.__svalue} 556 end 557 true 558 end 559 560 # ISO 15.3.2.2.2 561 # call-seq: 562 # enum.any? [{ |obj| block }] -> true or false 563 # enum.any?(pattern) -> true or false 564 # 565 # Passes each element of the collection to the given block. The method 566 # returns <code>true</code> if the block ever returns a value other 567 # than <code>false</code> or <code>nil</code>. If the block is not 568 # given, Ruby adds an implicit block of <code>{ |obj| obj }</code> that 569 # will cause #any? to return +true+ if at least one of the collection 570 # members is not +false+ or +nil+. 571 # 572 # If a pattern is supplied instead, the method returns whether 573 # <code>pattern === element</code> for any collection member. 574 # 575 # %w[ant bear cat].any? { |word| word.length >= 3 } #=> true 576 # %w[ant bear cat].any? { |word| word.length >= 4 } #=> true 577 # %w[ant bear cat].any?(/d/) #=> false 578 # [nil, true, 99].any?(Integer) #=> true 579 # [nil, true, 99].any? #=> true 580 # [].any? #=> false 581 # 582 def any?(pat=NONE, &block) 583 if pat != NONE 584 self.each{|*val| return true if pat === val.__svalue} 585 elsif block 586 self.each{|*val| return true if block.call(*val)} 587 else 588 self.each{|*val| return true if val.__svalue} 589 end 590 false 591 end 592 593 ## 594 # call-seq: 595 # enum.each_with_object(obj) { |(*args), memo_obj| ... } -> obj 596 # enum.each_with_object(obj) -> an_enumerator 597 # 598 # Iterates the given block for each element with an arbitrary 599 # object given, and returns the initially given object. 600 # 601 # If no block is given, returns an enumerator. 602 # 603 # (1..10).each_with_object([]) { |i, a| a << i*2 } 604 # #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] 605 # 606 607 def each_with_object(obj, &block) 608 return to_enum(:each_with_object, obj) unless block 609 610 self.each {|*val| block.call(val.__svalue, obj) } 611 obj 612 end 613 614 ## 615 # call-seq: 616 # enum.reverse_each { |item| block } -> enum 617 # enum.reverse_each -> an_enumerator 618 # 619 # Builds a temporary array and traverses that array in reverse order. 620 # 621 # If no block is given, an enumerator is returned instead. 622 # 623 # (1..3).reverse_each { |v| p v } 624 # 625 # produces: 626 # 627 # 3 628 # 2 629 # 1 630 # 631 632 def reverse_each(&block) 633 return to_enum :reverse_each unless block 634 635 ary = self.to_a 636 i = ary.size - 1 637 while i>=0 638 block.call(ary[i]) 639 i -= 1 640 end 641 self 642 end 643 644 ## 645 # call-seq: 646 # enum.cycle(n=nil) { |obj| block } -> nil 647 # enum.cycle(n=nil) -> an_enumerator 648 # 649 # Calls <i>block</i> for each element of <i>enum</i> repeatedly _n_ 650 # times or forever if none or +nil+ is given. If a non-positive 651 # number is given or the collection is empty, does nothing. Returns 652 # +nil+ if the loop has finished without getting interrupted. 653 # 654 # Enumerable#cycle saves elements in an internal array so changes 655 # to <i>enum</i> after the first pass have no effect. 656 # 657 # If no block is given, an enumerator is returned instead. 658 # 659 # a = ["a", "b", "c"] 660 # a.cycle { |x| puts x } # print, a, b, c, a, b, c,.. forever. 661 # a.cycle(2) { |x| puts x } # print, a, b, c, a, b, c. 662 # 663 664 def cycle(nv = nil, &block) 665 return to_enum(:cycle, nv) unless block 666 667 n = nil 668 669 if nv.nil? 670 n = -1 671 else 672 n = nv.__to_int 673 return nil if n <= 0 674 end 675 676 ary = [] 677 each do |*i| 678 ary.push(i) 679 yield(*i) 680 end 681 return nil if ary.empty? 682 683 while n < 0 || 0 < (n -= 1) 684 ary.each do |i| 685 yield(*i) 686 end 687 end 688 689 nil 690 end 691 692 ## 693 # call-seq: 694 # enum.find_index(value) -> int or nil 695 # enum.find_index { |obj| block } -> int or nil 696 # enum.find_index -> an_enumerator 697 # 698 # Compares each entry in <i>enum</i> with <em>value</em> or passes 699 # to <em>block</em>. Returns the index for the first for which the 700 # evaluated value is non-false. If no object matches, returns 701 # <code>nil</code> 702 # 703 # If neither block nor argument is given, an enumerator is returned instead. 704 # 705 # (1..10).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> nil 706 # (1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> 34 707 # (1..100).find_index(50) #=> 49 708 # 709 710 def find_index(val=NONE, &block) 711 return to_enum(:find_index, val) if !block && val == NONE 712 713 idx = 0 714 if block 715 self.each do |*e| 716 return idx if block.call(*e) 717 idx += 1 718 end 719 else 720 self.each do |*e| 721 return idx if e.__svalue == val 722 idx += 1 723 end 724 end 725 nil 726 end 727 728 ## 729 # call-seq: 730 # enum.zip(arg, ...) -> an_array_of_array 731 # enum.zip(arg, ...) { |arr| block } -> nil 732 # 733 # Takes one element from <i>enum</i> and merges corresponding 734 # elements from each <i>args</i>. This generates a sequence of 735 # <em>n</em>-element arrays, where <em>n</em> is one more than the 736 # count of arguments. The length of the resulting sequence will be 737 # <code>enum#size</code>. If the size of any argument is less than 738 # <code>enum#size</code>, <code>nil</code> values are supplied. If 739 # a block is given, it is invoked for each output array, otherwise 740 # an array of arrays is returned. 741 # 742 # a = [ 4, 5, 6 ] 743 # b = [ 7, 8, 9 ] 744 # 745 # a.zip(b) #=> [[4, 7], [5, 8], [6, 9]] 746 # [1, 2, 3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 747 # [1, 2].zip(a, b) #=> [[1, 4, 7], [2, 5, 8]] 748 # a.zip([1, 2], [8]) #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]] 749 # 750 # c = [] 751 # a.zip(b) { |x, y| c << x + y } #=> nil 752 # c #=> [11, 13, 15] 753 # 754 755 def zip(*arg, &block) 756 result = block ? nil : [] 757 arg = arg.map do |a| 758 unless a.respond_to?(:to_a) 759 raise TypeError, "wrong argument type #{a.class} (must respond to :to_a)" 760 end 761 a.to_a 762 end 763 764 i = 0 765 self.each do |*val| 766 a = [] 767 a.push(val.__svalue) 768 idx = 0 769 while idx < arg.size 770 a.push(arg[idx][i]) 771 idx += 1 772 end 773 i += 1 774 if result.nil? 775 block.call(a) 776 else 777 result.push(a) 778 end 779 end 780 result 781 end 782 783 ## 784 # call-seq: 785 # enum.to_h -> hash 786 # 787 # Returns the result of interpreting <i>enum</i> as a list of 788 # <tt>[key, value]</tt> pairs. 789 # 790 # %i[hello world].each_with_index.to_h 791 # # => {:hello => 0, :world => 1} 792 # 793 794 def to_h(&blk) 795 h = {} 796 if blk 797 self.each do |v| 798 v = blk.call(v) 799 raise TypeError, "wrong element type #{v.class} (expected Array)" unless v.is_a? Array 800 raise ArgumentError, "element has wrong array length (expected 2, was #{v.size})" if v.size != 2 801 h[v[0]] = v[1] 802 end 803 else 804 self.each do |*v| 805 v = v.__svalue 806 raise TypeError, "wrong element type #{v.class} (expected Array)" unless v.is_a? Array 807 raise ArgumentError, "element has wrong array length (expected 2, was #{v.size})" if v.size != 2 808 h[v[0]] = v[1] 809 end 810 end 811 h 812 end 813 814 def uniq(&block) 815 hash = {} 816 if block 817 self.each do|*v| 818 v = v.__svalue 819 hash[block.call(v)] ||= v 820 end 821 else 822 self.each do|*v| 823 v = v.__svalue 824 hash[v] ||= v 825 end 826 end 827 hash.values 828 end 829 830 def filter_map(&blk) 831 return to_enum(:filter_map) unless blk 832 833 ary = [] 834 self.each do |x| 835 x = blk.call(x) 836 ary.push x if x 837 end 838 ary 839 end 840 841 alias filter select 842 843 ## 844 # call-seq: 845 # enum.tally -> a_hash 846 # 847 # Tallys the collection. Returns a hash where the keys are the 848 # elements and the values are numbers of elements in the collection 849 # that correspond to the key. 850 # 851 # ["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1} 852 def tally 853 hash = {} 854 self.each do |x| 855 hash[x] = (hash[x]||0)+1 856 end 857 hash 858 end 859end 860