RubyDoc.info: Class: Code::Object::List – Documentation for code-ruby (1.9.8)

#any? ⇒ `Boolean`

Returns:

(Boolean)



1772
1773
1774

# File 'lib/code/object/list.rb', line 1772

def any?
  code_any?.truthy?
end

#call(**args) ⇒ `Object`

# File 'lib/code/object/list.rb', line 129

def call(**args)
  code_operator = args.fetch(:operator, nil).to_code
  code_arguments = args.fetch(:arguments, []).to_code
  globals = multi_fetch(args, *GLOBALS)
  code_value = code_arguments.code_first

  case code_operator.to_s
  when "join"
    sig(args) { String.maybe }
    code_join(code_value)
  when "sort"
    sig(args) { Function.maybe }
    code_sort(code_value, **globals)
  when "<<", "append"
    sig(args) { Object }
    code_append(code_value)
  when "+", "plus"
    sig(args) { List.maybe }
    code_arguments.any? ? code_plus(code_value) : code_self
  when "-", "minus"
    sig(args) { List }
    code_minus(code_value)
  when "any?"
    sig(args) { (Function | Class).maybe }
    code_any?(code_value, **globals)
  when "detect"
    sig(args) { (Function | Class).maybe }
    code_detect(code_value, **globals)
  when "each"
    sig(args) { (Function | Class).maybe }
    code_each(code_value, **globals)
  when "first"
    sig(args) { Integer.maybe }
    code_first(code_value)
  when "second"
    sig(args)
    code_second
  when "third"
    sig(args)
    code_third
  when "fourth"
    sig(args)
    code_fourth
  when "fifth"
    sig(args)
    code_fifth
  when "sixth"
    sig(args)
    code_sixth
  when "seventh"
    sig(args)
    code_seventh
  when "eighth"
    sig(args)
    code_eighth
  when "ninth"
    sig(args)
    code_ninth
  when "tenth"
    sig(args)
    code_tenth
  when "eleventh"
    sig(args)
    code_eleventh
  when "twelfth"
    sig(args)
    code_twelfth
  when "thirteenth"
    sig(args)
    code_thirteenth
  when "fourteenth"
    sig(args)
    code_fourteenth
  when "fifteenth"
    sig(args)
    code_fifteenth
  when "sixteenth"
    sig(args)
    code_sixteenth
  when "seventeenth"
    sig(args)
    code_seventeenth
  when "eighteenth"
    sig(args)
    code_eighteenth
  when "nineteenth"
    sig(args)
    code_nineteenth
  when "twentieth"
    sig(args)
    code_twentieth
  when "twenty_first"
    sig(args)
    code_twenty_first
  when "twenty_second"
    sig(args)
    code_twenty_second
  when "twenty_third"
    sig(args)
    code_twenty_third
  when "twenty_fourth"
    sig(args)
    code_twenty_fourth
  when "twenty_fifth"
    sig(args)
    code_twenty_fifth
  when "twenty_sixth"
    sig(args)
    code_twenty_sixth
  when "twenty_seventh"
    sig(args)
    code_twenty_seventh
  when "twenty_eighth"
    sig(args)
    code_twenty_eighth
  when "twenty_ninth"
    sig(args)
    code_twenty_ninth
  when "thirtieth"
    sig(args)
    code_thirtieth
  when "thirty_first"
    sig(args)
    code_thirty_first
  when "thirty_second"
    sig(args)
    code_thirty_second
  when "thirty_third"
    sig(args)
    code_thirty_third
  when "thirty_fourth"
    sig(args)
    code_thirty_fourth
  when "thirty_fifth"
    sig(args)
    code_thirty_fifth
  when "thirty_sixth"
    sig(args)
    code_thirty_sixth
  when "thirty_seventh"
    sig(args)
    code_thirty_seventh
  when "thirty_eighth"
    sig(args)
    code_thirty_eighth
  when "thirty_ninth"
    sig(args)
    code_thirty_ninth
  when "fortieth"
    sig(args)
    code_fortieth
  when "forty_first"
    sig(args)
    code_forty_first
  when "forty_second"
    sig(args)
    code_forty_second
  when "forty_third"
    sig(args)
    code_forty_third
  when "forty_fourth"
    sig(args)
    code_forty_fourth
  when "forty_fifth"
    sig(args)
    code_forty_fifth
  when "forty_sixth"
    sig(args)
    code_forty_sixth
  when "forty_seventh"
    sig(args)
    code_forty_seventh
  when "forty_eighth"
    sig(args)
    code_forty_eighth
  when "forty_ninth"
    sig(args)
    code_forty_ninth
  when "fiftieth"
    sig(args)
    code_fiftieth
  when "fifty_first"
    sig(args)
    code_fifty_first
  when "fifty_second"
    sig(args)
    code_fifty_second
  when "fifty_third"
    sig(args)
    code_fifty_third
  when "fifty_fourth"
    sig(args)
    code_fifty_fourth
  when "fifty_fifth"
    sig(args)
    code_fifty_fifth
  when "fifty_sixth"
    sig(args)
    code_fifty_sixth
  when "fifty_seventh"
    sig(args)
    code_fifty_seventh
  when "fifty_eighth"
    sig(args)
    code_fifty_eighth
  when "fifty_ninth"
    sig(args)
    code_fifty_ninth
  when "sixtieth"
    sig(args)
    code_sixtieth
  when "sixty_first"
    sig(args)
    code_sixty_first
  when "sixty_second"
    sig(args)
    code_sixty_second
  when "sixty_third"
    sig(args)
    code_sixty_third
  when "sixty_fourth"
    sig(args)
    code_sixty_fourth
  when "sixty_fifth"
    sig(args)
    code_sixty_fifth
  when "sixty_sixth"
    sig(args)
    code_sixty_sixth
  when "sixty_seventh"
    sig(args)
    code_sixty_seventh
  when "sixty_eighth"
    sig(args)
    code_sixty_eighth
  when "sixty_ninth"
    sig(args)
    code_sixty_ninth
  when "seventieth"
    sig(args)
    code_seventieth
  when "seventy_first"
    sig(args)
    code_seventy_first
  when "seventy_second"
    sig(args)
    code_seventy_second
  when "seventy_third"
    sig(args)
    code_seventy_third
  when "seventy_fourth"
    sig(args)
    code_seventy_fourth
  when "seventy_fifth"
    sig(args)
    code_seventy_fifth
  when "seventy_sixth"
    sig(args)
    code_seventy_sixth
  when "seventy_seventh"
    sig(args)
    code_seventy_seventh
  when "seventy_eighth"
    sig(args)
    code_seventy_eighth
  when "seventy_ninth"
    sig(args)
    code_seventy_ninth
  when "eightieth"
    sig(args)
    code_eightieth
  when "eighty_first"
    sig(args)
    code_eighty_first
  when "eighty_second"
    sig(args)
    code_eighty_second
  when "eighty_third"
    sig(args)
    code_eighty_third
  when "eighty_fourth"
    sig(args)
    code_eighty_fourth
  when "eighty_fifth"
    sig(args)
    code_eighty_fifth
  when "eighty_sixth"
    sig(args)
    code_eighty_sixth
  when "eighty_seventh"
    sig(args)
    code_eighty_seventh
  when "eighty_eighth"
    sig(args)
    code_eighty_eighth
  when "eighty_ninth"
    sig(args)
    code_eighty_ninth
  when "ninetieth"
    sig(args)
    code_ninetieth
  when "ninety_first"
    sig(args)
    code_ninety_first
  when "ninety_second"
    sig(args)
    code_ninety_second
  when "ninety_third"
    sig(args)
    code_ninety_third
  when "ninety_fourth"
    sig(args)
    code_ninety_fourth
  when "ninety_fifth"
    sig(args)
    code_ninety_fifth
  when "ninety_sixth"
    sig(args)
    code_ninety_sixth
  when "ninety_seventh"
    sig(args)
    code_ninety_seventh
  when "ninety_eighth"
    sig(args)
    code_ninety_eighth
  when "ninety_ninth"
    sig(args)
    code_ninety_ninth
  when "one_hundredth"
    sig(args)
    code_one_hundredth
  when "sample"
    sig(args) { Integer.maybe }
    code_sample(code_value)
  when "shuffle"
    sig(args)
    code_shuffle
  when "flatten"
    sig(args) { Integer.maybe }
    code_flatten(code_value)
  when "pop"
    sig(args) { Integer.maybe }
    code_pop(code_value)
  when "pop!"
    sig(args) { Integer.maybe }
    code_pop!(code_value)
  when "shift"
    sig(args) { Integer.maybe }
    code_shift(code_value)
  when "include?"
    sig(args) { Object }
    code_include?(code_value)
  when "last"
    sig(args)
    code_last
  when "map"
    sig(args) { (Function | Class).maybe }
    code_map(code_value, **globals)
  when "map!"
    sig(args) { (Function | Class).maybe }
    code_map!(code_value, **globals)
  when "max"
    sig(args) { (Function | Class).maybe }
    code_max(code_value, **globals)
  when "none?"
    sig(args) { (Function | Class).maybe }
    code_none?(code_value, **globals)
  when "all?"
    sig(args) { (Function | Class).maybe }
    code_all?(code_value, **globals)
  when "reduce"
    sig(args) { (Function | Class).maybe }
    code_reduce(code_value, **globals)
  when "reverse"
    sig(args)
    code_reverse
  when "select"
    sig(args) { (Function | Class).maybe }
    code_select(code_value, **globals)
  when "select!"
    sig(args) { (Function | Class).maybe }
    code_select!(code_value, **globals)
  when "compact"
    sig(args) { (Function | Class).maybe }
    code_compact(code_value, **globals)
  when "compact!"
    sig(args) { (Function | Class).maybe }
    code_compact!(code_value, **globals)
  when "reject"
    sig(args) { (Function | Class).maybe }
    code_reject(code_value, **globals)
  when "reject!"
    sig(args) { (Function | Class).maybe }
    code_reject!(code_value, **globals)
  when "size"
    sig(args)
    code_size
  when "sum"
    sig(args)
    code_sum
  when "uniq"
    sig(args) { (Function | Class).maybe }
    code_uniq(code_value, **globals)
  when "many?"
    sig(args)
    code_many?
  when "positive?"
    sig(args)
    code_positive?
  when "negative?"
    sig(args)
    code_negative?
  when "zero?"
    sig(args)
    code_zero?
  when "one?"
    sig(args)
    code_one?
  when "two?"
    sig(args)
    code_two?
  when "three?"
    sig(args)
    code_three?
  when "four?"
    sig(args)
    code_four?
  when "five?"
    sig(args)
    code_five?
  when "six?"
    sig(args)
    code_six?
  when "seven?"
    sig(args)
    code_seven?
  when "eight?"
    sig(args)
    code_eight?
  when "nine?"
    sig(args)
    code_nine?
  when "ten?"
    sig(args)
    code_ten?
  when "eleven?"
    sig(args)
    code_eleven?
  when "twelve?"
    sig(args)
    code_twelve?
  when "thirteen?"
    sig(args)
    code_thirteen?
  when "fourteen?"
    sig(args)
    code_fourteen?
  when "fifteen?"
    sig(args)
    code_fifteen?
  when "sixteen?"
    sig(args)
    code_sixteen?
  when "seventeen?"
    sig(args)
    code_seventeen?
  when "eighteen?"
    sig(args)
    code_eighteen?
  when "nineteen?"
    sig(args)
    code_nineteen?
  when "twenty?"
    sig(args)
    code_twenty?
  when "twenty_one?"
    sig(args)
    code_twenty_one?
  when "twenty_two?"
    sig(args)
    code_twenty_two?
  when "twenty_three?"
    sig(args)
    code_twenty_three?
  when "twenty_four?"
    sig(args)
    code_twenty_four?
  when "twenty_five?"
    sig(args)
    code_twenty_five?
  when "twenty_six?"
    sig(args)
    code_twenty_six?
  when "twenty_seven?"
    sig(args)
    code_twenty_seven?
  when "twenty_eight?"
    sig(args)
    code_twenty_eight?
  when "twenty_nine?"
    sig(args)
    code_twenty_nine?
  when "thirty?"
    sig(args)
    code_thirty?
  when "thirty_one?"
    sig(args)
    code_thirty_one?
  when "thirty_two?"
    sig(args)
    code_thirty_two?
  when "thirty_three?"
    sig(args)
    code_thirty_three?
  when "thirty_four?"
    sig(args)
    code_thirty_four?
  when "thirty_five?"
    sig(args)
    code_thirty_five?
  when "thirty_six?"
    sig(args)
    code_thirty_six?
  when "thirty_seven?"
    sig(args)
    code_thirty_seven?
  when "thirty_eight?"
    sig(args)
    code_thirty_eight?
  when "thirty_nine?"
    sig(args)
    code_thirty_nine?
  when "forty?"
    sig(args)
    code_forty?
  when "forty_one?"
    sig(args)
    code_forty_one?
  when "forty_two?"
    sig(args)
    code_forty_two?
  when "forty_three?"
    sig(args)
    code_forty_three?
  when "forty_four?"
    sig(args)
    code_forty_four?
  when "forty_five?"
    sig(args)
    code_forty_five?
  when "forty_six?"
    sig(args)
    code_forty_six?
  when "forty_seven?"
    sig(args)
    code_forty_seven?
  when "forty_eight?"
    sig(args)
    code_forty_eight?
  when "forty_nine?"
    sig(args)
    code_forty_nine?
  when "fifty?"
    sig(args)
    code_fifty?
  when "fifty_one?"
    sig(args)
    code_fifty_one?
  when "fifty_two?"
    sig(args)
    code_fifty_two?
  when "fifty_three?"
    sig(args)
    code_fifty_three?
  when "fifty_four?"
    sig(args)
    code_fifty_four?
  when "fifty_five?"
    sig(args)
    code_fifty_five?
  when "fifty_six?"
    sig(args)
    code_fifty_six?
  when "fifty_seven?"
    sig(args)
    code_fifty_seven?
  when "fifty_eight?"
    sig(args)
    code_fifty_eight?
  when "fifty_nine?"
    sig(args)
    code_fifty_nine?
  when "sixty?"
    sig(args)
    code_sixty?
  when "sixty_one?"
    sig(args)
    code_sixty_one?
  when "sixty_two?"
    sig(args)
    code_sixty_two?
  when "sixty_three?"
    sig(args)
    code_sixty_three?
  when "sixty_four?"
    sig(args)
    code_sixty_four?
  when "sixty_five?"
    sig(args)
    code_sixty_five?
  when "sixty_six?"
    sig(args)
    code_sixty_six?
  when "sixty_seven?"
    sig(args)
    code_sixty_seven?
  when "sixty_eight?"
    sig(args)
    code_sixty_eight?
  when "sixty_nine?"
    sig(args)
    code_sixty_nine?
  when "seventy?"
    sig(args)
    code_seventy?
  when "seventy_one?"
    sig(args)
    code_seventy_one?
  when "seventy_two?"
    sig(args)
    code_seventy_two?
  when "seventy_three?"
    sig(args)
    code_seventy_three?
  when "seventy_four?"
    sig(args)
    code_seventy_four?
  when "seventy_five?"
    sig(args)
    code_seventy_five?
  when "seventy_six?"
    sig(args)
    code_seventy_six?
  when "seventy_seven?"
    sig(args)
    code_seventy_seven?
  when "seventy_eight?"
    sig(args)
    code_seventy_eight?
  when "seventy_nine?"
    sig(args)
    code_seventy_nine?
  when "eighty?"
    sig(args)
    code_eighty?
  when "eighty_one?"
    sig(args)
    code_eighty_one?
  when "eighty_two?"
    sig(args)
    code_eighty_two?
  when "eighty_three?"
    sig(args)
    code_eighty_three?
  when "eighty_four?"
    sig(args)
    code_eighty_four?
  when "eighty_five?"
    sig(args)
    code_eighty_five?
  when "eighty_six?"
    sig(args)
    code_eighty_six?
  when "eighty_seven?"
    sig(args)
    code_eighty_seven?
  when "eighty_eight?"
    sig(args)
    code_eighty_eight?
  when "eighty_nine?"
    sig(args)
    code_eighty_nine?
  when "ninety?"
    sig(args)
    code_ninety?
  when "ninety_one?"
    sig(args)
    code_ninety_one?
  when "ninety_two?"
    sig(args)
    code_ninety_two?
  when "ninety_three?"
    sig(args)
    code_ninety_three?
  when "ninety_four?"
    sig(args)
    code_ninety_four?
  when "ninety_five?"
    sig(args)
    code_ninety_five?
  when "ninety_six?"
    sig(args)
    code_ninety_six?
  when "ninety_seven?"
    sig(args)
    code_ninety_seven?
  when "ninety_eight?"
    sig(args)
    code_ninety_eight?
  when "ninety_nine?"
    sig(args)
    code_ninety_nine?
  when "one_hundred?"
    sig(args)
    code_one_hundred?
  else
    super
  end
end

#code_all?(argument = nil, **globals) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/code/object/list.rb', line 1493

def code_all?(argument = nil, **globals)
  code_argument = argument.to_code

  index = 0

  Boolean.new(
    raw.all? do |code_element|
      if code_argument.is_a?(Function)
        code_argument
          .call(
            arguments: List.new([code_element, Integer.new(index), self]),
            **globals
          )
          .truthy?
          .tap { index += 1 }
      elsif code_argument.is_a?(Class)
        code_element.is_a?(code_argument.raw).tap { index += 1 }
      else
        true.tap { index += 1 }
      end
    rescue Error::Next => e
      e.code_value.truthy?.tap { index += 1 }
    end
  )
end

#code_any?(argument = nil, **globals) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/code/object/list.rb', line 849

def code_any?(argument = nil, **globals)
  code_argument = argument.to_code

  index = 0

  Boolean.new(
    raw.any? do |code_element|
      if code_argument.is_a?(Function)
        code_argument
          .call(
            arguments: List.new([code_element, Integer.new(index), self]),
            **globals
          )
          .truthy?
          .tap { index += 1 }
      elsif code_argument.is_a?(Class)
        code_element.is_a?(code_argument.raw).tap { index += 1 }
      else
        true.tap { index += 1 }
      end
    rescue Error::Next => e
      e.code_value.tap { index += 1 }
    end
  )
end

#code_append(other) ⇒ `Object`

# File 'lib/code/object/list.rb', line 875

def code_append(other)
  code_other = other.to_code

  raw << code_other

  self
end

#code_compact(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1545

def code_compact(argument = nil, **globals)
  code_argument = argument.to_code

  index = 0

  List.new(
    raw.select do |code_element|
      if code_argument.is_a?(Function)
        code_argument
          .call(
            arguments: List.new([code_element, Integer.new(index), self]),
            **globals
          )
          .truthy?
          .tap { index += 1 }
      elsif code_argument.is_a?(Class)
        code_element.is_a?(code_argument.raw).tap { index += 1 }
      else
        code_element.truthy?.tap { index += 1 }
      end
    rescue Error::Next => e
      e.code_value.truhty?.tap { index += 1 }
    end
  )
end

#code_compact!(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1571

def code_compact!(argument = nil, **globals)
  code_argument = argument.to_code

  index = 0

  raw.select! do |code_element|
    if code_argument.is_a?(Function)
      code_argument
        .call(
          arguments: List.new([code_element, Integer.new(index), self]),
          **globals
        )
        .truthy?
        .tap { index += 1 }
    elsif code_argument.is_a?(Class)
      code_element.is_a?(code_argument.raw).tap { index += 1 }
    else
      code_element.truthy?.tap { index += 1 }
    end
  rescue Error::Next => e
    e.code_value.truhty?.tap { index += 1 }
  end

  self
end

#code_deep_duplicate ⇒ `Object`



1749
1750
1751

# File 'lib/code/object/list.rb', line 1749

def code_deep_duplicate
  List.new(raw.dup.map(&:code_deep_duplicate))
end

#code_detect(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 895

def code_detect(argument = nil, **globals)
  code_argument = argument.to_code

  raw.detect.with_index do |code_element, index|
    if code_argument.is_a?(Function)
      code_argument.call(
        arguments: List.new([code_element, Integer.new(index), self]),
        **globals
      ).truthy?
    elsif code_argument.is_a?(Class)
      code_element.is_a?(code_argument.raw)
    else
      false
    end
  rescue Error::Next => e
    e.code_value
  end || Nothing.new
end

#code_each(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 914

def code_each(argument = nil, **globals)
  code_argument = argument.to_code

  raw.each.with_index do |code_element, index|
    if code_argument.is_a?(Function)
      code_argument.call(
        arguments: List.new([code_element, Integer.new(index), self]),
        **globals
      )
    elsif code_argument.is_a?(Class)
      code_argument.raw.new(code_element)
    end
  rescue Error::Next => e
    e.code_value
  end

  self
end

#code_eighteenth ⇒ `Object`



1011
1012
1013

# File 'lib/code/object/list.rb', line 1011

def code_eighteenth
  code_nth(17)
end

#code_eighth ⇒ `Object`



971
972
973

# File 'lib/code/object/list.rb', line 971

def code_eighth
  code_nth(7)
end

#code_eightieth ⇒ `Object`



1259
1260
1261

# File 'lib/code/object/list.rb', line 1259

def code_eightieth
  code_nth(79)
end

#code_eighty_eighth ⇒ `Object`



1291
1292
1293

# File 'lib/code/object/list.rb', line 1291

def code_eighty_eighth
  code_nth(87)
end

#code_eighty_fifth ⇒ `Object`



1279
1280
1281

# File 'lib/code/object/list.rb', line 1279

def code_eighty_fifth
  code_nth(84)
end

#code_eighty_first ⇒ `Object`



1263
1264
1265

# File 'lib/code/object/list.rb', line 1263

def code_eighty_first
  code_nth(80)
end

#code_eighty_fourth ⇒ `Object`



1275
1276
1277

# File 'lib/code/object/list.rb', line 1275

def code_eighty_fourth
  code_nth(83)
end

#code_eighty_ninth ⇒ `Object`



1295
1296
1297

# File 'lib/code/object/list.rb', line 1295

def code_eighty_ninth
  code_nth(88)
end

#code_eighty_second ⇒ `Object`



1267
1268
1269

# File 'lib/code/object/list.rb', line 1267

def code_eighty_second
  code_nth(81)
end

#code_eighty_seventh ⇒ `Object`



1287
1288
1289

# File 'lib/code/object/list.rb', line 1287

def code_eighty_seventh
  code_nth(86)
end

#code_eighty_sixth ⇒ `Object`



1283
1284
1285

# File 'lib/code/object/list.rb', line 1283

def code_eighty_sixth
  code_nth(85)
end

#code_eighty_third ⇒ `Object`



1271
1272
1273

# File 'lib/code/object/list.rb', line 1271

def code_eighty_third
  code_nth(82)
end

#code_eleventh ⇒ `Object`



983
984
985

# File 'lib/code/object/list.rb', line 983

def code_eleventh
  code_nth(10)
end

#code_fetch(key) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1766

def code_fetch(key)
  code_key = key.to_code.code_to_integer

  raw.fetch(code_key.raw, Nothing.new)
end

#code_fifteenth ⇒ `Object`



999
1000
1001

# File 'lib/code/object/list.rb', line 999

def code_fifteenth
  code_nth(14)
end

#code_fifth ⇒ `Object`



959
960
961

# File 'lib/code/object/list.rb', line 959

def code_fifth
  code_nth(4)
end

#code_fiftieth ⇒ `Object`



1139
1140
1141

# File 'lib/code/object/list.rb', line 1139

def code_fiftieth
  code_nth(49)
end

#code_fifty_eighth ⇒ `Object`



1171
1172
1173

# File 'lib/code/object/list.rb', line 1171

def code_fifty_eighth
  code_nth(57)
end

#code_fifty_fifth ⇒ `Object`



1159
1160
1161

# File 'lib/code/object/list.rb', line 1159

def code_fifty_fifth
  code_nth(54)
end

#code_fifty_first ⇒ `Object`



1143
1144
1145

# File 'lib/code/object/list.rb', line 1143

def code_fifty_first
  code_nth(50)
end

#code_fifty_fourth ⇒ `Object`



1155
1156
1157

# File 'lib/code/object/list.rb', line 1155

def code_fifty_fourth
  code_nth(53)
end

#code_fifty_ninth ⇒ `Object`



1175
1176
1177

# File 'lib/code/object/list.rb', line 1175

def code_fifty_ninth
  code_nth(58)
end

#code_fifty_second ⇒ `Object`



1147
1148
1149

# File 'lib/code/object/list.rb', line 1147

def code_fifty_second
  code_nth(51)
end

#code_fifty_seventh ⇒ `Object`



1167
1168
1169

# File 'lib/code/object/list.rb', line 1167

def code_fifty_seventh
  code_nth(56)
end

#code_fifty_sixth ⇒ `Object`



1163
1164
1165

# File 'lib/code/object/list.rb', line 1163

def code_fifty_sixth
  code_nth(55)
end

#code_fifty_third ⇒ `Object`



1151
1152
1153

# File 'lib/code/object/list.rb', line 1151

def code_fifty_third
  code_nth(52)
end

#code_first(value = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 933

def code_first(value = nil)
  code_value = value.to_code

  if code_value.nothing?
    raw.first || Nothing.new
  else
    List.new(raw.first(code_value.raw))
  end
end

#code_flatten(level = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1357

def code_flatten(level = nil)
  code_level = level.to_code
  code_level = Integer.new(-1) if code_level.nothing?
  level = code_level.raw

  List.new(
    raw.reduce([]) do |acc, code_element|
      if code_element.is_a?(List) && level != 0
        if level.positive?
          acc + code_element.code_flatten(level - 1).raw
        else
          acc + code_element.code_flatten(level).raw
        end
      else
        acc + [code_element]
      end
    end
  )
end

#code_fortieth ⇒ `Object`



1099
1100
1101

# File 'lib/code/object/list.rb', line 1099

def code_fortieth
  code_nth(39)
end

#code_forty_eighth ⇒ `Object`



1131
1132
1133

# File 'lib/code/object/list.rb', line 1131

def code_forty_eighth
  code_nth(47)
end

#code_forty_fifth ⇒ `Object`



1119
1120
1121

# File 'lib/code/object/list.rb', line 1119

def code_forty_fifth
  code_nth(44)
end

#code_forty_first ⇒ `Object`



1103
1104
1105

# File 'lib/code/object/list.rb', line 1103

def code_forty_first
  code_nth(40)
end

#code_forty_fourth ⇒ `Object`



1115
1116
1117

# File 'lib/code/object/list.rb', line 1115

def code_forty_fourth
  code_nth(43)
end

#code_forty_ninth ⇒ `Object`



1135
1136
1137

# File 'lib/code/object/list.rb', line 1135

def code_forty_ninth
  code_nth(48)
end

#code_forty_second ⇒ `Object`



1107
1108
1109

# File 'lib/code/object/list.rb', line 1107

def code_forty_second
  code_nth(41)
end

#code_forty_seventh ⇒ `Object`



1127
1128
1129

# File 'lib/code/object/list.rb', line 1127

def code_forty_seventh
  code_nth(46)
end

#code_forty_sixth ⇒ `Object`



1123
1124
1125

# File 'lib/code/object/list.rb', line 1123

def code_forty_sixth
  code_nth(45)
end

#code_forty_third ⇒ `Object`



1111
1112
1113

# File 'lib/code/object/list.rb', line 1111

def code_forty_third
  code_nth(42)
end

#code_fourteenth ⇒ `Object`



995
996
997

# File 'lib/code/object/list.rb', line 995

def code_fourteenth
  code_nth(13)
end

#code_fourth ⇒ `Object`



955
956
957

# File 'lib/code/object/list.rb', line 955

def code_fourth
  code_nth(3)
end

#code_get(argument) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1753

def code_get(argument)
  code_argument = argument.to_code

  raw[code_argument.raw] || Nothing.new
end

#code_include?(other) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/code/object/list.rb', line 1398

def code_include?(other)
  code_other = other.to_code

  Boolean.new(raw.include?(code_other))
end

#code_join(separator = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1681

def code_join(separator = nil)
  code_separator = separator.to_s.to_code

  String.new(raw.join(code_separator.raw))
end

#code_last ⇒ `Object`



1404
1405
1406

# File 'lib/code/object/list.rb', line 1404

def code_last
  raw.last || Nothing.new
end

#code_map(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1408

def code_map(argument = nil, **globals)
  code_argument = argument.to_code

  List.new(
    raw.map.with_index do |code_element, index|
      if code_argument.is_a?(Function)
        code_argument.call(
          arguments: List.new([code_element, Integer.new(index), self]),
          **globals
        )
      elsif code_argument.is_a?(Class)
        code_argument.raw.new(code_element)
      else
        Nothing.new
      end
    rescue Error::Next => e
      e.code_value
    end
  )
end

#code_map!(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1429

def code_map!(argument = nil, **globals)
  code_argument = argument.to_code

  raw.map!.with_index do |code_element, index|
    if code_argument.is_a?(Function)
      code_argument.call(
        arguments: List.new([code_element, Integer.new(index), self]),
        **globals
      )
    elsif code_argument.is_a?(Class)
      code_argument.raw.new(code_element)
    else
      Nothing.new
    end
  rescue Error::Next => e
    e.code_value
  end

  self
end

#code_max(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1450

def code_max(argument = nil, **globals)
  code_argument = argument.to_code

  raw.max_by.with_index do |code_element, index|
    if code_argument.is_a?(Function)
      code_argument.call(
        arguments: List.new([code_element, Integer.new(index), self]),
        **globals
      ).truthy?
    else
      code_element
    end
  rescue Error::Next => e
    e.code_value
  end || Nothing.new
end

#code_minus(other) ⇒ `Object`

# File 'lib/code/object/list.rb', line 889

def code_minus(other)
  code_other = other.to_code

  List.new(raw - code_other.raw)
end

#code_nineteenth ⇒ `Object`



1015
1016
1017

# File 'lib/code/object/list.rb', line 1015

def code_nineteenth
  code_nth(18)
end

#code_ninetieth ⇒ `Object`



1299
1300
1301

# File 'lib/code/object/list.rb', line 1299

def code_ninetieth
  code_nth(89)
end

#code_ninety_eighth ⇒ `Object`



1331
1332
1333

# File 'lib/code/object/list.rb', line 1331

def code_ninety_eighth
  code_nth(97)
end

#code_ninety_fifth ⇒ `Object`



1319
1320
1321

# File 'lib/code/object/list.rb', line 1319

def code_ninety_fifth
  code_nth(94)
end

#code_ninety_first ⇒ `Object`



1303
1304
1305

# File 'lib/code/object/list.rb', line 1303

def code_ninety_first
  code_nth(90)
end

#code_ninety_fourth ⇒ `Object`



1315
1316
1317

# File 'lib/code/object/list.rb', line 1315

def code_ninety_fourth
  code_nth(93)
end

#code_ninety_ninth ⇒ `Object`



1335
1336
1337

# File 'lib/code/object/list.rb', line 1335

def code_ninety_ninth
  code_nth(98)
end

#code_ninety_second ⇒ `Object`



1307
1308
1309

# File 'lib/code/object/list.rb', line 1307

def code_ninety_second
  code_nth(91)
end

#code_ninety_seventh ⇒ `Object`



1327
1328
1329

# File 'lib/code/object/list.rb', line 1327

def code_ninety_seventh
  code_nth(96)
end

#code_ninety_sixth ⇒ `Object`



1323
1324
1325

# File 'lib/code/object/list.rb', line 1323

def code_ninety_sixth
  code_nth(95)
end

#code_ninety_third ⇒ `Object`



1311
1312
1313

# File 'lib/code/object/list.rb', line 1311

def code_ninety_third
  code_nth(92)
end

#code_ninth ⇒ `Object`



975
976
977

# File 'lib/code/object/list.rb', line 975

def code_ninth
  code_nth(8)
end

#code_none?(argument = nil, **globals) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/code/object/list.rb', line 1467

def code_none?(argument = nil, **globals)
  code_argument = argument.to_code

  index = 0

  Boolean.new(
    raw.none? do |code_element|
      if code_argument.is_a?(Function)
        code_argument
          .call(
            arguments: List.new([code_element, Integer.new(index), self]),
            **globals
          )
          .truthy?
          .tap { index += 1 }
      elsif code_argument.is_a?(Class)
        code_element.is_a?(code_argument.raw).tap { index += 1 }
      else
        true.tap { index += 1 }
      end
    rescue Error::Next => e
      e.code_value.truthy?.tap { index += 1 }
    end
  )
end

#code_nth(index) ⇒ `Object`



943
944
945

# File 'lib/code/object/list.rb', line 943

def code_nth(index)
  raw[index] || Nothing.new
end

#code_one_hundredth ⇒ `Object`



1339
1340
1341

# File 'lib/code/object/list.rb', line 1339

def code_one_hundredth
  code_nth(99)
end

#code_plus(other) ⇒ `Object`

# File 'lib/code/object/list.rb', line 883

def code_plus(other)
  code_other = other.to_code

  List.new(raw + code_other.raw)
end

#code_pop(n = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1377

def code_pop(n = nil)
  code_n = n.to_code
  n = code_n.raw

  code_n.nothing? ? raw.dup.pop || Nothing.new : List.new(raw.dup.pop(n))
end

#code_pop!(n = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1384

def code_pop!(n = nil)
  code_n = n.to_code
  n = code_n.raw

  code_n.nothing? ? raw.pop || Nothing.new : List.new(raw.pop(n))
end

#code_reduce(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1519

def code_reduce(argument = nil, **globals)
  code_argument = argument.to_code

  index = 0

  raw.reduce do |code_acc, code_element|
    if code_argument.is_a?(Function)
      code_argument
        .call(
          arguments:
            List.new([code_acc, code_element, Integer.new(index), self]),
          **globals
        )
        .tap { index += 1 }
    else
      code_acc.tap { index += 1 }
    end
  rescue Error::Next => e
    e.code_value.tap { index += 1 }
  end || Nothing.new
end

#code_reject(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1639

def code_reject(argument = nil, **globals)
  code_argument = argument.to_code

  List.new(
    raw.reject.with_index do |code_element, index|
      if code_argument.is_a?(Function)
        code_argument.call(
          arguments: List.new([code_element, Integer.new(index), self]),
          **globals
        ).truthy?
      elsif code_argument.is_a?(Class)
        code_element.is_a?(code_argument.raw)
      else
        false
      end
    rescue Error::Next => e
      e.code_value.truthy?
    end
  )
end

#code_reject!(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1660

def code_reject!(argument = nil, **globals)
  code_argument = argument.to_code

  raw.reject!.with_index do |code_element, index|
    if code_argument.is_a?(Function)
      code_argument.call(
        arguments: List.new([code_element, Integer.new(index), self]),
        **globals
      ).truthy?
    elsif code_argument.is_a?(Class)
      code_element.is_a?(code_argument.raw)
    else
      false
    end
  rescue Error::Next => e
    e.code_value.truthy?
  end

  self
end

#code_reverse ⇒ `Object`



1541
1542
1543

# File 'lib/code/object/list.rb', line 1541

def code_reverse
  List.new(raw.reverse)
end

#code_sample(value = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1343

def code_sample(value = nil)
  code_value = value.to_code

  if code_value.nothing?
    raw.sample || Nothing.new
  else
    List.new(raw.sample(code_value.raw))
  end
end

#code_second ⇒ `Object`



947
948
949

# File 'lib/code/object/list.rb', line 947

def code_second
  code_nth(1)
end

#code_select(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1597

def code_select(argument = nil, **globals)
  code_argument = argument.to_code

  List.new(
    raw.select.with_index do |code_element, index|
      if code_argument.is_a?(Function)
        code_argument.call(
          arguments: List.new([code_element, Integer.new(index), self]),
          **globals
        ).truthy?
      elsif code_argument.is_a?(Class)
        code_element.is_a?(code_argument.raw)
      else
        false
      end
    rescue Error::Next => e
      e.code_value.truthy?
    end
  )
end

#code_select!(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1618

def code_select!(argument = nil, **globals)
  code_argument = argument.to_code

  raw.select!.with_index do |code_element, index|
    if code_argument.is_a?(Function)
      code_argument.call(
        arguments: List.new([code_element, Integer.new(index), self]),
        **globals
      ).truthy?
    elsif code_argument.is_a?(Class)
      code_element.is_a?(code_argument.raw)
    else
      false
    end
  rescue Error::Next => e
    e.code_value.truthy?
  end

  self
end

#code_set(key, value) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1759

def code_set(key, value)
  code_key = key.to_code.code_to_integer
  code_value = value.to_code
  raw[code_key.raw] = code_value
  code_value
end

#code_seventeenth ⇒ `Object`



1007
1008
1009

# File 'lib/code/object/list.rb', line 1007

def code_seventeenth
  code_nth(16)
end

#code_seventh ⇒ `Object`



967
968
969

# File 'lib/code/object/list.rb', line 967

def code_seventh
  code_nth(6)
end

#code_seventieth ⇒ `Object`



1219
1220
1221

# File 'lib/code/object/list.rb', line 1219

def code_seventieth
  code_nth(69)
end

#code_seventy_eighth ⇒ `Object`



1251
1252
1253

# File 'lib/code/object/list.rb', line 1251

def code_seventy_eighth
  code_nth(77)
end

#code_seventy_fifth ⇒ `Object`



1239
1240
1241

# File 'lib/code/object/list.rb', line 1239

def code_seventy_fifth
  code_nth(74)
end

#code_seventy_first ⇒ `Object`



1223
1224
1225

# File 'lib/code/object/list.rb', line 1223

def code_seventy_first
  code_nth(70)
end

#code_seventy_fourth ⇒ `Object`



1235
1236
1237

# File 'lib/code/object/list.rb', line 1235

def code_seventy_fourth
  code_nth(73)
end

#code_seventy_ninth ⇒ `Object`



1255
1256
1257

# File 'lib/code/object/list.rb', line 1255

def code_seventy_ninth
  code_nth(78)
end

#code_seventy_second ⇒ `Object`



1227
1228
1229

# File 'lib/code/object/list.rb', line 1227

def code_seventy_second
  code_nth(71)
end

#code_seventy_seventh ⇒ `Object`



1247
1248
1249

# File 'lib/code/object/list.rb', line 1247

def code_seventy_seventh
  code_nth(76)
end

#code_seventy_sixth ⇒ `Object`



1243
1244
1245

# File 'lib/code/object/list.rb', line 1243

def code_seventy_sixth
  code_nth(75)
end

#code_seventy_third ⇒ `Object`



1231
1232
1233

# File 'lib/code/object/list.rb', line 1231

def code_seventy_third
  code_nth(72)
end

#code_shift(n = nil) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1391

def code_shift(n = nil)
  code_n = n.to_code
  n = code_n.raw

  code_n.nothing? ? raw.shift || Nothing.new : List.new(raw.shift(n))
end

#code_shuffle ⇒ `Object`



1353
1354
1355

# File 'lib/code/object/list.rb', line 1353

def code_shuffle
  List.new(raw.shuffle)
end

#code_sixteenth ⇒ `Object`



1003
1004
1005

# File 'lib/code/object/list.rb', line 1003

def code_sixteenth
  code_nth(15)
end

#code_sixth ⇒ `Object`



963
964
965

# File 'lib/code/object/list.rb', line 963

def code_sixth
  code_nth(5)
end

#code_sixtieth ⇒ `Object`



1179
1180
1181

# File 'lib/code/object/list.rb', line 1179

def code_sixtieth
  code_nth(59)
end

#code_sixty_eighth ⇒ `Object`



1211
1212
1213

# File 'lib/code/object/list.rb', line 1211

def code_sixty_eighth
  code_nth(67)
end

#code_sixty_fifth ⇒ `Object`



1199
1200
1201

# File 'lib/code/object/list.rb', line 1199

def code_sixty_fifth
  code_nth(64)
end

#code_sixty_first ⇒ `Object`



1183
1184
1185

# File 'lib/code/object/list.rb', line 1183

def code_sixty_first
  code_nth(60)
end

#code_sixty_fourth ⇒ `Object`



1195
1196
1197

# File 'lib/code/object/list.rb', line 1195

def code_sixty_fourth
  code_nth(63)
end

#code_sixty_ninth ⇒ `Object`



1215
1216
1217

# File 'lib/code/object/list.rb', line 1215

def code_sixty_ninth
  code_nth(68)
end

#code_sixty_second ⇒ `Object`



1187
1188
1189

# File 'lib/code/object/list.rb', line 1187

def code_sixty_second
  code_nth(61)
end

#code_sixty_seventh ⇒ `Object`



1207
1208
1209

# File 'lib/code/object/list.rb', line 1207

def code_sixty_seventh
  code_nth(66)
end

#code_sixty_sixth ⇒ `Object`



1203
1204
1205

# File 'lib/code/object/list.rb', line 1203

def code_sixty_sixth
  code_nth(65)
end

#code_sixty_third ⇒ `Object`



1191
1192
1193

# File 'lib/code/object/list.rb', line 1191

def code_sixty_third
  code_nth(62)
end

#code_size ⇒ `Object`



1706
1707
1708

# File 'lib/code/object/list.rb', line 1706

def code_size
  Integer.new(raw.size)
end

#code_sort(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1687

def code_sort(argument = nil, **globals)
  code_argument = argument.to_code

  List.new(
    raw.sort_by.with_index do |code_element, index|
      if code_argument.is_a?(Function)
        code_argument.call(
          arguments: List.new([code_element, Integer.new(index), self]),
          **globals
        )
      else
        code_element
      end
    rescue Error::Next => e
      e.code_value
    end
  )
end

#code_sum ⇒ `Object`



1745
1746
1747

# File 'lib/code/object/list.rb', line 1745

def code_sum
  raw.inject(&:code_plus) || Nothing.new
end

#code_tenth ⇒ `Object`



979
980
981

# File 'lib/code/object/list.rb', line 979

def code_tenth
  code_nth(9)
end

#code_third ⇒ `Object`



951
952
953

# File 'lib/code/object/list.rb', line 951

def code_third
  code_nth(2)
end

#code_thirteenth ⇒ `Object`



991
992
993

# File 'lib/code/object/list.rb', line 991

def code_thirteenth
  code_nth(12)
end

#code_thirtieth ⇒ `Object`



1059
1060
1061

# File 'lib/code/object/list.rb', line 1059

def code_thirtieth
  code_nth(29)
end

#code_thirty_eighth ⇒ `Object`



1091
1092
1093

# File 'lib/code/object/list.rb', line 1091

def code_thirty_eighth
  code_nth(37)
end

#code_thirty_fifth ⇒ `Object`



1079
1080
1081

# File 'lib/code/object/list.rb', line 1079

def code_thirty_fifth
  code_nth(34)
end

#code_thirty_first ⇒ `Object`



1063
1064
1065

# File 'lib/code/object/list.rb', line 1063

def code_thirty_first
  code_nth(30)
end

#code_thirty_fourth ⇒ `Object`



1075
1076
1077

# File 'lib/code/object/list.rb', line 1075

def code_thirty_fourth
  code_nth(33)
end

#code_thirty_ninth ⇒ `Object`



1095
1096
1097

# File 'lib/code/object/list.rb', line 1095

def code_thirty_ninth
  code_nth(38)
end

#code_thirty_second ⇒ `Object`



1067
1068
1069

# File 'lib/code/object/list.rb', line 1067

def code_thirty_second
  code_nth(31)
end

#code_thirty_seventh ⇒ `Object`



1087
1088
1089

# File 'lib/code/object/list.rb', line 1087

def code_thirty_seventh
  code_nth(36)
end

#code_thirty_sixth ⇒ `Object`



1083
1084
1085

# File 'lib/code/object/list.rb', line 1083

def code_thirty_sixth
  code_nth(35)
end

#code_thirty_third ⇒ `Object`



1071
1072
1073

# File 'lib/code/object/list.rb', line 1071

def code_thirty_third
  code_nth(32)
end

#code_twelfth ⇒ `Object`



987
988
989

# File 'lib/code/object/list.rb', line 987

def code_twelfth
  code_nth(11)
end

#code_twentieth ⇒ `Object`



1019
1020
1021

# File 'lib/code/object/list.rb', line 1019

def code_twentieth
  code_nth(19)
end

#code_twenty_eighth ⇒ `Object`



1051
1052
1053

# File 'lib/code/object/list.rb', line 1051

def code_twenty_eighth
  code_nth(27)
end

#code_twenty_fifth ⇒ `Object`



1039
1040
1041

# File 'lib/code/object/list.rb', line 1039

def code_twenty_fifth
  code_nth(24)
end

#code_twenty_first ⇒ `Object`



1023
1024
1025

# File 'lib/code/object/list.rb', line 1023

def code_twenty_first
  code_nth(20)
end

#code_twenty_fourth ⇒ `Object`



1035
1036
1037

# File 'lib/code/object/list.rb', line 1035

def code_twenty_fourth
  code_nth(23)
end

#code_twenty_ninth ⇒ `Object`



1055
1056
1057

# File 'lib/code/object/list.rb', line 1055

def code_twenty_ninth
  code_nth(28)
end

#code_twenty_second ⇒ `Object`



1027
1028
1029

# File 'lib/code/object/list.rb', line 1027

def code_twenty_second
  code_nth(21)
end

#code_twenty_seventh ⇒ `Object`



1047
1048
1049

# File 'lib/code/object/list.rb', line 1047

def code_twenty_seventh
  code_nth(26)
end

#code_twenty_sixth ⇒ `Object`



1043
1044
1045

# File 'lib/code/object/list.rb', line 1043

def code_twenty_sixth
  code_nth(25)
end

#code_twenty_third ⇒ `Object`



1031
1032
1033

# File 'lib/code/object/list.rb', line 1031

def code_twenty_third
  code_nth(22)
end

#code_uniq(argument = nil, **globals) ⇒ `Object`

# File 'lib/code/object/list.rb', line 1710

def code_uniq(argument = nil, **globals)
  code_argument = argument.to_code

  unless code_argument.is_a?(Function) || code_argument.is_a?(Class)
    return List.new(raw.uniq)
  end

  if code_argument.is_a?(Class)
    return List.new(
      raw
        .select { |code_element| code_element.is_a?(code_argument.raw) }
        .uniq
    )
  end

  index = 0

  List.new(
    raw.uniq do |code_element|
      if code_argument.is_a?(Function)
        code_argument
          .call(
            arguments: List.new([code_element, Integer.new(index), self]),
            **globals
          )
          .tap { index += 1 }
      else
        code_element.tap { index += 1 }
      end
    rescue Error::Next => e
      e.code_value.tap { index += 1 }
    end
  )
end

#present? ⇒ `Boolean`

Returns:

(Boolean)



1776
1777
1778

# File 'lib/code/object/list.rb', line 1776

def present?
  raw.present?
end

Class: Code::Object::List

Direct Known Subclasses

Constant Summary

Constants inherited from Code::Object

Instance Attribute Summary

Attributes included from Concerns::Shared

Instance Method Summary collapse

Methods inherited from Code::Object

Methods included from Concerns::Shared

Constructor Details

#initialize(*args, **_kargs, &_block) ⇒ List

Instance Method Details

#any? ⇒ Boolean

#call(**args) ⇒ Object

#code_all?(argument = nil, **globals) ⇒ Boolean

#code_any?(argument = nil, **globals) ⇒ Boolean

#code_append(other) ⇒ Object

#code_compact(argument = nil, **globals) ⇒ Object

#code_compact!(argument = nil, **globals) ⇒ Object

#code_deep_duplicate ⇒ Object

#code_detect(argument = nil, **globals) ⇒ Object

#code_each(argument = nil, **globals) ⇒ Object

#code_eighteenth ⇒ Object

#code_eighth ⇒ Object

#code_eightieth ⇒ Object

#code_eighty_eighth ⇒ Object

#code_eighty_fifth ⇒ Object

#code_eighty_first ⇒ Object

#code_eighty_fourth ⇒ Object

#code_eighty_ninth ⇒ Object

#code_eighty_second ⇒ Object

#code_eighty_seventh ⇒ Object

#code_eighty_sixth ⇒ Object

#code_eighty_third ⇒ Object

#code_eleventh ⇒ Object

#code_fetch(key) ⇒ Object

#code_fifteenth ⇒ Object

#code_fifth ⇒ Object

#code_fiftieth ⇒ Object

#code_fifty_eighth ⇒ Object

#code_fifty_fifth ⇒ Object

#code_fifty_first ⇒ Object

#code_fifty_fourth ⇒ Object

#code_fifty_ninth ⇒ Object

#code_fifty_second ⇒ Object

#code_fifty_seventh ⇒ Object

#code_fifty_sixth ⇒ Object

#code_fifty_third ⇒ Object

#code_first(value = nil) ⇒ Object

#code_flatten(level = nil) ⇒ Object

#code_fortieth ⇒ Object

#code_forty_eighth ⇒ Object

#code_forty_fifth ⇒ Object

#code_forty_first ⇒ Object

#code_forty_fourth ⇒ Object

#code_forty_ninth ⇒ Object

#code_forty_second ⇒ Object

#code_forty_seventh ⇒ Object

#code_forty_sixth ⇒ Object

#code_forty_third ⇒ Object

#code_fourteenth ⇒ Object

#code_fourth ⇒ Object

#code_get(argument) ⇒ Object

#code_include?(other) ⇒ Boolean

#code_join(separator = nil) ⇒ Object

#code_last ⇒ Object

#code_map(argument = nil, **globals) ⇒ Object

#code_map!(argument = nil, **globals) ⇒ Object

#code_max(argument = nil, **globals) ⇒ Object

#code_minus(other) ⇒ Object

#code_nineteenth ⇒ Object

#code_ninetieth ⇒ Object

#code_ninety_eighth ⇒ Object

#code_ninety_fifth ⇒ Object

#code_ninety_first ⇒ Object

#code_ninety_fourth ⇒ Object

#code_ninety_ninth ⇒ Object

#code_ninety_second ⇒ Object

#code_ninety_seventh ⇒ Object

#code_ninety_sixth ⇒ Object

#initialize(*args, **_kargs, &_block) ⇒ `List`

#any? ⇒ `Boolean`

#call(**args) ⇒ `Object`

#code_all?(argument = nil, **globals) ⇒ `Boolean`

#code_any?(argument = nil, **globals) ⇒ `Boolean`

#code_append(other) ⇒ `Object`

#code_compact(argument = nil, **globals) ⇒ `Object`

#code_compact!(argument = nil, **globals) ⇒ `Object`

#code_deep_duplicate ⇒ `Object`

#code_detect(argument = nil, **globals) ⇒ `Object`

#code_each(argument = nil, **globals) ⇒ `Object`

#code_eighteenth ⇒ `Object`

#code_eighth ⇒ `Object`

#code_eightieth ⇒ `Object`

#code_eighty_eighth ⇒ `Object`

#code_eighty_fifth ⇒ `Object`

#code_eighty_first ⇒ `Object`

#code_eighty_fourth ⇒ `Object`

#code_eighty_ninth ⇒ `Object`

#code_eighty_second ⇒ `Object`

#code_eighty_seventh ⇒ `Object`

#code_eighty_sixth ⇒ `Object`

#code_eighty_third ⇒ `Object`

#code_eleventh ⇒ `Object`

#code_fetch(key) ⇒ `Object`

#code_fifteenth ⇒ `Object`

#code_fifth ⇒ `Object`

#code_fiftieth ⇒ `Object`

#code_fifty_eighth ⇒ `Object`

#code_fifty_fifth ⇒ `Object`

#code_fifty_first ⇒ `Object`

#code_fifty_fourth ⇒ `Object`

#code_fifty_ninth ⇒ `Object`

#code_fifty_second ⇒ `Object`

#code_fifty_seventh ⇒ `Object`

#code_fifty_sixth ⇒ `Object`

#code_fifty_third ⇒ `Object`

#code_first(value = nil) ⇒ `Object`

#code_flatten(level = nil) ⇒ `Object`

#code_fortieth ⇒ `Object`

#code_forty_eighth ⇒ `Object`

#code_forty_fifth ⇒ `Object`

#code_forty_first ⇒ `Object`

#code_forty_fourth ⇒ `Object`

#code_forty_ninth ⇒ `Object`

#code_forty_second ⇒ `Object`

#code_forty_seventh ⇒ `Object`

#code_forty_sixth ⇒ `Object`

#code_forty_third ⇒ `Object`

#code_fourteenth ⇒ `Object`

#code_fourth ⇒ `Object`

#code_get(argument) ⇒ `Object`

#code_include?(other) ⇒ `Boolean`

#code_join(separator = nil) ⇒ `Object`

#code_last ⇒ `Object`

#code_map(argument = nil, **globals) ⇒ `Object`

#code_map!(argument = nil, **globals) ⇒ `Object`

#code_max(argument = nil, **globals) ⇒ `Object`

#code_minus(other) ⇒ `Object`

#code_nineteenth ⇒ `Object`

#code_ninetieth ⇒ `Object`

#code_ninety_eighth ⇒ `Object`

#code_ninety_fifth ⇒ `Object`

#code_ninety_first ⇒ `Object`

#code_ninety_fourth ⇒ `Object`

#code_ninety_ninth ⇒ `Object`

#code_ninety_second ⇒ `Object`

#code_ninety_seventh ⇒ `Object`

#code_ninety_sixth ⇒ `Object`

#code_ninety_third ⇒ `Object`

#code_ninth ⇒ `Object`

#code_none?(argument = nil, **globals) ⇒ `Boolean`

#code_nth(index) ⇒ `Object`

#code_one_hundredth ⇒ `Object`

#code_plus(other) ⇒ `Object`

#code_pop(n = nil) ⇒ `Object`

#code_pop!(n = nil) ⇒ `Object`

#code_reduce(argument = nil, **globals) ⇒ `Object`

#code_reject(argument = nil, **globals) ⇒ `Object`

#code_reject!(argument = nil, **globals) ⇒ `Object`