class Array

return ArrayContext for each execute

Example¶ ↑

[*'a'..'c'].>>.ord # => [97, 98, 99]
[*'a'..'c'].>>.'ord' # => [97, 98, 99]
[*'aa'..'ac'].>>.gsub("a", "c") # => ['cc', 'cb', 'cc']

# File lib/open_classes/array/gte_gte.rb, line 37
def >>(dummy = nil)
  ArrayContext.new(self)
end

return average

Example¶ ↑

[*1..6].average # => 3.5
[1.5, 2.5].average # => 2.0
[*'a'..'z'].average # => raise TypeError

# File lib/open_classes/array/average.rb, line 13
def average
  fail TypeError, 'you have to use elements that is Numeric' unless all? { |v|v.is_a? Numeric }
  sum.to_f / size
end

exchange arrays elements

Example¶ ↑

[*1..6].exchange!(1, 5) # => [1, 6, 3, 4, 5, 2]
[*1..6].exchange!(1, -1) # => [1, 6, 3, 4, 5, 2]
[*1..6].exchange!(1, 6) # => [*1..6]
[].exchange!(1, 2) # => []

# File lib/open_classes/array/exchange.rb, line 14
def exchange!(one_index, other_index)
  return self unless one_index.respond_to? :to_i
  return self unless other_index.respond_to? :to_i
  one_index = one_index.to_i
  other_index = other_index.to_i
  return self if one_index.abs >= size
  return self if other_index.abs >= size
  tmp_one = self[one_index]
  self[one_index] = self[other_index]
  self[other_index] = tmp_one
  self
end

Array(Array, Array…) to html table format.

Example¶ ↑

[['header1', 'header2', 'header3'],['line1_1', 'line1_2', 'line1_3']].to_html_table

result

<table>
  <tr>
    <th>header1</th>
    <th>header2</th>
    <th>header3</th>
  </tr>
  <tr>
    <td>line1_1</td>
    <td>line1_2</td>
    <td>line1_3</td>
  </tr>
</table>

# File lib/open_classes/array/to_html_table.rb, line 26
def to_html_table(options = { no_header: false })
  options[:no_header] = false if options[:no_header].nil?
  cnt = options[:no_header] ? 1 : 0
  ret = reduce(['<table>']) do |rets, lines|
    ret = lines.reduce([]) do |ret, column|
      tag = (cnt == 0) ? 'th' : 'td'
      ret << "    <#{tag}>#{column}</#{tag}>"
      ret
    end
    cnt += 1
    inner_tr = ret.join("\n")
    rets << "  <tr>\n#{inner_tr}\n  </tr>"
  end.join("\n") + "\n</table>\n"
end

Array(Array, Array…) to table format.

Example¶ ↑

[['header1', 'header2', 'header3'],['line1_1', 'line1_2', 'line1_3']].to_table

result

|header1|header2|header3|
|line1_1|line1_2|line1_3|

# File lib/open_classes/array/to_table.rb, line 16
def to_table(position = :right)
  ret = reduce([]) do |rets, lines|
    ret = lines.reduce([]) { |a, e|a << e; a }
    rets << "|#{ret.join('|')}|"
  end.join("\n") + "\n"
  ret.justify_table(position)
end

Arrays loop together.

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end

# File lib/open_classes/array/together.rb, line 16
def together
  if_not_contain_array_rails_type_error
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    instance_eval "yield(#{eval_each_str})"
  end
end

Arrays bulk at.

together_at has alias :tat

same elements size case

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_at 2 # => output ['three', 3]

different elements size case

alpha = %w{one two three}
numbers = %w{1 2}
[alpha, numbers].together_at 2 # => output ['three', nil]

# File lib/open_classes/array/together_at.rb, line 23
def together_at(index)
  if_not_contain_array_rails_type_error
  reduce([]) { |ats, list|ats << list.at(index) }
end

Arrays bulk clear.

together_clear has alias :tclear

same elements size case

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_clear # => output [[],[]]

# File lib/open_classes/array/together_clear.rb, line 18
def together_clear
  if_not_contain_array_rails_type_error
  each(&:clear)
end

Arrays bulk compact.(immutable)

together_compact has alias :tcompact

same elements size case

alpha = ['a','b','c', nil,'d']
numbers = [1, 2, nil, 3]
lists = [alpha, numbers]
ret = lists.together_compact
print lists # => output [['a','b','c', nil,'d'], [1, 2, nil, 3]]
print ret # => output [['a','b','c','d'], [1, 2, 3]]

# File lib/open_classes/array/together_compact.rb, line 21
def together_compact
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.compact }
end

Arrays bulk compact!.(mutable)

together_compact! has alias :tcompact!

same elements size case

alpha = ['a','b','c', nil,'d']
numbers = [1, 2, nil, 3]
lists = [alpha, numbers]
ret = lists.together_compact!
print lists # => output [['a','b','c','d'], [1, 2, 3]]
print ret # => output [['a','b','c','d'], [1, 2, 3]]

# File lib/open_classes/array/together_compact.rb, line 37
def together_compact!
  if_not_contain_array_rails_type_error
  each(&:compact!)
end

Arrays bulk concat.

together_concat has alias :tconcat

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end

# File lib/open_classes/array/together_concat.rb, line 19
def together_concat(other)
  if_not_contain_array_rails_type_error
  each { |list|list.concat other }
end

Arrays bulk delete.

together_delete has alias :tdelete

if delete target is exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 2
print ret # => 2
print lists # => output [[1, 3, 4], [3, 4, 5]]

if delete target is not exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 6
print ret # => nil
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

if delete target is not exist and use block

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete(6) { 999 }
print ret # => 999
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

# File lib/open_classes/array/together_delete.rb, line 37
def together_delete(value)
  if_not_contain_array_rails_type_error
  ret = []
  each { |list|ret << list.delete(value) }
  default_return = block_given? ? yield : nil
  ret.compact.size == 0 ? default_return : value
end

Arrays bulk delete_at.

together_delete_at has alias :tdelete_at

if delete_at target is exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at 2
print ret # => [3, 4]
print lists # => output [[1, 2, 4], [2, 3, 5]]

if delete_at target is not exist

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at 6
print ret # => [nil, nil]
print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]

if delete_at target is exist(minus index)

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete_at -3
print ret # => [2, 3]
print lists # => output [[1, 3, 4], [2, 4, 5]]

# File lib/open_classes/array/together_delete_at.rb, line 37
def together_delete_at(index)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.delete_at(index) }
end

Arrays bulk delete_if.

together_delete_if has alias :tdelete_if

if delete_if target is exist. return self.

lists = [[1, 2, 3, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => [[2, 4], [4, 8]]

if delete_if target is not exist. return nil.

lists = [[2, 2, 4, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => nil

# File lib/open_classes/array/together_delete_if.rb, line 23
def together_delete_if(&block)
  if_not_contain_array_rails_type_error
  have_deleted = false
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    is_delete = instance_eval "yield(#{eval_each_str})"
    if is_delete
      each { |e|e.delete_at i }
      have_deleted = true
    end
  end
  have_deleted ? self : nil
end

Arrays bulk empty?.

together_empty? has alias :tempty?

empty case

lists = [[], []]
ret = lists.together_empty?
print ret # => true

not empty case

lists = [[1], []]
ret = lists.together_empty?
print ret # => false

# File lib/open_classes/array/together_empty.rb, line 23
def together_empty?
  if_not_contain_array_rails_type_error
  is_empty = true
  each { |list|is_empty &&= list.empty? }
  is_empty
end

Arrays bulk fill.

together_fill has alias :tfill

not use block case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(99)
print ret # => [[99, 99, 99, 99, 99], [99, 99, 99, 99, 99]]

use block, no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill { |i|(i + 1) + 1 }
print ret # => [[2, 3, 4, 5, 6], [2, 3, 4, 5, 6]]

use block, has args case

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(2) { |i|(i + 1) + 1 }
print ret # => [[1, 2, 4, 5, 6], [6, 7, 4, 5, 6]]

# File lib/open_classes/array/together_fill.rb, line 28
def together_fill(fill_value = nil, &block)
  if_not_contain_array_rails_type_error
  if block
    fill_value = 0 if fill_value.nil?
    first.each_with_index do |i_v, i|
      next if i < fill_value
      each { |list|list[i] = yield(i) }
    end
  else
    each { |list|list.fill fill_value }
  end
  self
end

Arrays bulk first.

together_first has alias :tfirst

no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_first
print ret # => [1, 6]

has args 2 case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 2
print ret # => [[1, 2], [6, 7]]

has args 0 case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 0
print ret # => [[], []]

has args over size case

lists = [[*1..5], [*6..10]]
ret = lists.together_first 6
print ret # => [[*1..5], [*6..10]]

# File lib/open_classes/array/together_first.rb, line 33
def together_first(index = nil)
  if_not_contain_array_rails_type_error
  each_return = index == 0 ? '[]' : index.nil? ? 'list.first' : 'list.first(index)'
  reduce([]) { |ret, list|ret << eval(each_return, binding) }
end

Arrays bulk include?.

together_include? has alias :tinclude?

both include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5
print ret # => true

one include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9
print ret # => true

both not include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10
print ret # => false

both include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5, true
print ret # => [true, true]

one include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9, true
print ret # => [false, true]

both not include multi ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10, true
print ret # => [false, false]

# File lib/open_classes/array/together_include.rb, line 43
def together_include?(value, is_multi = false)
  if_not_contain_array_rails_type_error
  return reduce([]) { |ret, list|ret << list.include?(value) } if is_multi
  reduce(false) { |ret, list|ret ||= list.include?(value) }
end

Arrays bulk index.

together_index has alias :tindex

both index exist case

lists = [[*1..5], [*5..9]]
ret = lists.together_index 5
print ret # => [4, 0]

one include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_index 4
print ret # => [3, nil]

both not include single ret case

lists = [[*1..5], [*5..9]]
ret = lists.together_index 10
print ret # => [nil, nil]

# File lib/open_classes/array/together_index.rb, line 28
def together_index(value)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.index(value) }
end

Arrays bulk insert.

together_insert has alias :tinsert

both insert exist case

lists = [[*1..5], [*5..9]]
ret = lists.together_insert(1, 55, 66)
print ret # => [[1, 55, 66, 2, 3, 4, 5], [5, 55, 66, 6, 7, 8, 9]]

both insert exist and minus index case

lists = [[*1..5], [*5..9]]
ret = lists.together_insert(-2, 55, 66)
print ret # => [[1, 2, 3, 4, 55, 66, 5], [5, 6, 7, 8, 55, 66, 9]]

both insert exist case

lists = [[*1..5], [*5..9]]
ret = lists.together_insert(6, 55, 66)
print ret # => [[1, 2, 3, 4, 5, nil, 55, 66], [5, 6, 7, 8, 9, nil, 55, 66]],

# File lib/open_classes/array/together_insert.rb, line 28
def together_insert(index, *args)
  if_not_contain_array_rails_type_error
  each { |list|list.insert(index, *args) }
end

Arrays bulk last.

together_last has alias :tlast

no args case

lists = [[*1..5], [*6..10]]
ret = lists.together_last
print ret # => [5, 10]

has args 2 case

lists = [[*1..5], [*6..10]]
ret = lists.together_last 2
print ret # => [[4, 5], [9, 10]]

has args 0 case

lists = [[*1..5], [*6..10]]
ret = lists.together_last 0
print ret # => [[], []]

has args over size case

lists = [[*1..5], [*6..10]]
ret = lists.together_last 6
print ret # => [[*1..5], [*6..10]]

# File lib/open_classes/array/together_last.rb, line 33
def together_last(index = nil)
  if_not_contain_array_rails_type_error
  each_return = index == 0 ? '[]' : index.nil? ? 'list.last' : 'list.last(index)'
  reduce([]) { |ret, list|ret << eval(each_return, binding) }
end

Arrays together map.

together_map has aliases [:tmap, :together_collect, :tcollect]

if you want to single Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_map do |first, second|
  "#{first}:#{second}\n"
end # => output one:1, two:2, three:3

if you want to multi Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_map do |first, second|
  ["#{first}:#{second}", "#{second}:#{first}"]
end # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]

# File lib/open_classes/array/together_map.rb, line 27
def together_map
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_map(ret, each_ret, i)
  end
  ret
end

Arrays together map!.

together_map! has aliases [:tmap!, :together_collect!, :tcollect!]

if you want to single Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
ary = [alpha, numbers]
ret = ary.together_map! do |first, second|
  "#{first}:#{second}"
end
print ret # => output ['one:1', 'two:2', 'three:3']
print ary # => output ['one:1', 'two:2', 'three:3']

if you want to multi Array return

alpha = %w{one two three}
numbers = %w{1 2 3}
ary = [alpha, numbers]
ret = ary.together_map! do |first, second|
  ["#{first}:#{second}", "#{second}:#{first}"]
end
print ret # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
print ary # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]

# File lib/open_classes/array/together_map.rb, line 61
def together_map!
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_map(ret, each_ret, i)
  end
  clear
  ret.each { |v|self << v }
end

Arrays bulk pop.

together_pop has alias :tpop

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_pop
print ret # => [2, 6]
print lists # => [1, 5]

empty case

lists = [[], []]
ret = lists.together_pop
print ret # => [nil, nil]
print lists # => [[], []]

not empty case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_pop 2
print ret # => [[1, 2], [5, 6]]
print lists # => [[], []]

not empty case with args

lists = [[], []]
ret = lists.together_pop 2
print ret # => [[], []]
print lists # => [[], []]

# File lib/open_classes/array/together_pop.rb, line 37
def together_pop(count = nil)
  if_not_contain_array_rails_type_error
  if count.nil?
    reduce([]) { |ret, list|ret << list.pop }
  else
    reduce([]) { |ret, list|ret << list.pop(count) }
  end
end

Arrays loop together reduce.

together_reduce has aliases [:treduce, :together_inject, :tinject]

if you want to single return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce{|memo, first, second|memo + first + second}
print ret # => output  20

if you want to single return with init value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce(10){|memo, first, second|memo + first + second}
print ret # => output  30

if you want to single return with init string value

firsts = %w{a b c}
seconds =  %w{1 2 3}
ret = [firsts, seconds].together_reduce('start-'){|memo, first, second|memo + first + second}
print ret # => output 'start-a1b2c3'

if you want to single return with init Array value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce([]){|memo, first, second|memo << first + second}
print ret # => output [5, 4, 6, 5]

if you want to single return with init Hash value

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_reduce({}){|memo, first, second|memo[first] = second;memo}
print ret # => output {1=>4, 2=>2, 3=>3, 4=>1}

# File lib/open_classes/array/together_reduce.rb, line 43
def together_reduce(init = nil)
  if_not_contain_array_rails_type_error
  memo = initial_memo init
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    memo = instance_eval "yield(memo, #{eval_each_str})"
  end
  memo
end

Arrays bulk reverse.

together_reverse has alias :treverse

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_reverse
print ret # => [[2, 1], [6, 5]]
print lists # => [[1, 2], [5, 6]]

one empty case

lists = [[1, 2], []]
ret = lists.together_reverse
print ret # => [[2, 1], []]
print lists # => [[1, 2], []]

# File lib/open_classes/array/together_reverse.rb, line 25
def together_reverse
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.reverse }
end

Arrays bulk reverse!.

together_reverse! has alias :treverse!

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_reverse!
print ret # => [[2, 1], [6, 5]]
print lists # => [[2, 1], [6, 5]]

one empty case

lists = [[1, 2], []]
ret = lists.together_reverse!
print ret # => [[2, 1], []]
print lists # => [[2, 1], []]

# File lib/open_classes/array/together_reverse.rb, line 46
def together_reverse!
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.reverse! }
end

Arrays bulk sample.

together_sample has alias :tsample

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_sample
print ret # => [1 or 2, 5 or 6]

empty case

lists = [[], []]
ret = lists.together_sample
print ret # => [nil, nil]

not empty case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_sample 2
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]

not empty case with args

lists = [[], []]
ret = lists.together_sample 2
print ret # => [[], []]

not empty, over size case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_sample 3
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]

# File lib/open_classes/array/together_sample.rb, line 39
def together_sample(count = nil)
  if_not_contain_array_rails_type_error
  if count.nil?
    reduce([]) { |ret, list|ret << list.sample }
  else
    reduce([]) { |ret, list|ret << list.sample(count) }
  end
end

Arrays loop together select.

together_select has aliases [:tselect, :together_find_all, :tfindall]

if you want to single Array return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_select{|first, second|first == second}
print ret # => output  [[2, 3], [2, 3]]

if you want to multi Array return

firsts = [1, 2, 3, 4]
seconds =  [4, 2, 3, 1]
ret = [firsts, seconds].together_select{|first, second|[first.odd?, second.even?]}
print ret # => output  [[1, 3], [4, 2]]

# File lib/open_classes/array/together_select.rb, line 25
def together_select
  if_not_contain_array_rails_type_error
  ret = []
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i
    each_ret = instance_eval "yield(#{eval_each_str})"
    ret = set_together_each_return_select(ret, each_ret, i)
  end
  ret
end

Arrays bulk shift.

together_shift has alias :tshift

not empty case

lists = [[1, 2], [5, 6]]
ret = lists.together_shift
print ret # => [1, 5]
print lists # => [2, 6]

empty case

lists = [[], []]
ret = lists.together_shift
print ret # => [nil, nil]
print lists # => [[], []]

not empty case with args

lists = [[1, 2], [5, 6]]
ret = lists.together_shift 2
print ret # => [[1, 2], [5, 6]]
print lists # => [[], []]

not empty case with args

lists = [[], []]
ret = lists.together_shift 2
print ret # => [[], []]
print lists # => [[], []]

# File lib/open_classes/array/together_shift.rb, line 37
def together_shift(count = nil)
  if_not_contain_array_rails_type_error
  if count.nil?
    reduce([]) { |ret, list|ret << list.shift }
  else
    reduce([]) { |ret, list|ret << list.shift(count) }
  end
end

Arrays bulk shuffle.

together_shuffle has alias :tshuffle

lists = [[1, 2], [5, 6]]
ret = lists.together_shuffle
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]

# File lib/open_classes/array/together_shuffle.rb, line 17
def together_shuffle(count = nil)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.shuffle }
end

Arrays bulk slice.

together_slice has alias :tslice

Examples¶ ↑

single args case

lists = [[*1..5], [*6..10]]
ret = lists.together_slice 2
print ret # => [3, 8]

multi args case

lists = [[*1..5], [*6..10]]
ret = lists.together_slice 2, 2
print ret # => [[3, 4], [8, 9]]

range args case

lists = [[*1..5], [*6..10]]
ret = lists.together_slice (2..3)
print ret # => [[3, 4], [8, 9]]

# File lib/open_classes/array/together_slice.rb, line 32
def together_slice(*args)
  if_not_contain_array_rails_type_error
  reduce([]) { |ret, list|ret << list.slice(*args) }
end

Arrays loop together with index.

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_with_index do |first, second, index|
  print "#{index.to_s}:#{first}:#{second}\n"  # => output 0:one:1, 1:two:2, 2:three:3
end

# File lib/open_classes/array/together_with_index.rb, line 17
def together_with_index
  if_not_contain_array_rails_type_error
  first.each_with_index do |i_v, i|
    eval_each_str = get_args_str_for_together i, true
    instance_eval "yield(#{eval_each_str})"
  end
end

return uniq size

Example¶ ↑

([*1..6] + [2,3]).uniq_size # => 6
[*1..6].uniq_size # => 6
[].uniq_size # => 0

# File lib/open_classes/array/uniq_size.rb, line 13
def uniq_size
  uniq.size
end