Class: Code::Object::Dictionary

Inherits:

Code::Object

• Object
• Code::Object
• Code::Object::Dictionary

Defined in:

lib/code/object/dictionary.rb

Direct Known Subclasses

Context, Parameter, Smtp

Constant Summary

Constants inherited from Code::Object

NUMBER_CLASSES

Instance Attribute Summary

Attributes included from Concerns::Shared

#methods, #raw

Instance Method Summary

• #call(**args) ⇒ Object
• #code_any?(argument, **globals) ⇒ Boolean
• #code_clear ⇒ Object
• #code_compact ⇒ Object
• #code_compact! ⇒ Object
• #code_compare(other) ⇒ Object
• #code_deep_duplicate ⇒ Object
• #code_delete(*arguments, index: 0, **globals) ⇒ Object
• #code_delete_if(argument, **globals) ⇒ Object
• #code_delete_unless(argument, **globals) ⇒ Object
• #code_dig(*arguments) ⇒ Object
• #code_each(argument, **globals) ⇒ Object
• #code_empty? ⇒ Boolean
• #code_except(*arguments) ⇒ Object
• #code_fetch(*arguments, index: 0, **globals) ⇒ Object
• #code_fetch_values(*arguments) ⇒ Object
• #code_flatten(level = nil) ⇒ Object
• #code_get(key) ⇒ Object
• #code_has_key?(key) ⇒ Boolean
• #code_has_value?(key) ⇒ Boolean
• #code_inferior(other) ⇒ Object
• #code_inferior_or_equal(other) ⇒ Object
• #code_invert ⇒ Object
• #code_keep_if(argument, **globals) ⇒ Object
• #code_keep_unless(argument, **globals) ⇒ Object
• #code_key(value, function = nil, **globals) ⇒ Object
• #code_keys ⇒ Object
• #code_merge(*arguments, **globals) ⇒ Object
• #code_merge!(*arguments, **globals) ⇒ Object
• #code_select(argument, **globals) ⇒ Object
• #code_select!(argument, **globals) ⇒ Object
• #code_set(key, value) ⇒ Object
• #code_size ⇒ Object
• #code_superior(other) ⇒ Object
• #code_superior_or_equal(other) ⇒ Object
• #code_to_context ⇒ Object
• #code_to_query(namespace = nil) ⇒ Object
• #code_transform_values(function, **globals) ⇒ Object
• #code_values ⇒ Object
• #initialize(*args, **kargs, &_block) ⇒ Dictionary constructor

  A new instance of Dictionary.

Methods inherited from Code::Object

code_new, #code_new, maybe, #name, repeat, |

Methods included from Concerns::Shared

#<=>, #==, #as_json, #code_and, #code_as_json, #code_different, #code_duplicate, #code_equal, #code_exclamation_mark, #code_exclusive_range, #code_falsy?, code_fetch, code_get, #code_inclusive_range, #code_inspect, #code_methods, #code_name, #code_nothing?, #code_or, #code_self, code_set, #code_something?, #code_strict_different, #code_strict_equal, #code_to_boolean, #code_to_class, #code_to_date, #code_to_decimal, #code_to_dictionary, #code_to_duration, #code_to_integer, #code_to_json, #code_to_list, #code_to_nothing, #code_to_parameter, #code_to_range, #code_to_string, #code_to_time, #code_truthy?, #eql?, #falsy?, #hash, #inspect, #multi_fetch, #nothing?, #sig, #something?, #succ, #to_code, #to_i, #to_json, #to_s, #truthy?

Constructor Details

#initialize(*args, **kargs, &_block) ⇒ Dictionary

Returns a new instance of Dictionary.

# File 'lib/code/object/dictionary.rb', line 114

def initialize(*args, **kargs, &_block)
  self.raw =
    args
      .map do |arg|
        if arg.is_an?(::Hash)
          arg.transform_keys(&:to_code).transform_values(&:to_code)
        elsif arg.is_a?(Dictionary)
          arg.raw.transform_keys(&:to_code).transform_values(&:to_code)
        elsif arg.is_a?(Node::FunctionParameter)
          arg.to_h.transform_keys(&:to_code).transform_values(&:to_code)
        else
          {}
        end
      end
      .reduce({}, &:merge)
      .merge(kargs.transform_keys(&:to_code).transform_values(&:to_code))
end

Instance Method Details

#call(**args) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 132

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

  case code_operator.to_s
  when "<", "inferior"
    sig(args) { Dictionary }
    code_inferior(code_value)
  when "<=", "inferior_or_equal"
    sig(args) { Dictionary }
    code_inferior_or_equal(code_value)
  when "<=>", "compare"
    sig(args) { Dictionary }
    code_compare(code_value)
  when ">", "superior"
    sig(args) { Dictionary }
    code_superior(code_value)
  when ">=", "superior_or_equal"
    sig(args) { Dictionary }
    code_superior_or_equal(code_value)
  when "[]", "at", "get"
    sig(args) { Object }
    code_get(code_value)
  when "any?"
    sig(args) { (Function | Class).maybe }
    code_any?(code_value, **globals)
  when "clear"
    sig(args)
    code_clear
  when "compact!"
    sig(args)
    code_compact!
  when "compact"
    sig(args)
    code_compact
  when "delete"
    sig(args) { Object.repeat(1) }
    code_delete(*code_arguments.raw, **globals)
  when "delete_if"
    sig(args) { Function | Class }
    code_delete_if(code_value, **globals)
  when "delete_unless"
    sig(args) { Function | Class }
    code_delete_unless(code_value, **globals)
  when "dig"
    sig(args) { Object.repeat(1) }
    code_dig(*code_arguments.raw)
  when "each"
    sig(args) { Function }
    code_each(code_value, **globals)
  when "empty?"
    sig(args)
    code_empty?
  when "except"
    sig(args) { Object.repeat(1) }
    code_except(*code_arguments.raw)
  when "fetch"
    sig(args) { Object.repeat(1) }
    code_fetch(*code_arguments.raw, **globals)
  when "fetch_values"
    sig(args) { Object.repeat(1) }
    code_fetch_values(*code_arguments.raw)
  when "flatten"
    sig(args) { Integer.maybe }
    code_flatten(code_value)
  when "has_key?"
    sig(args) { Object }
    code_has_key?(code_value)
  when "has_value?"
    sig(args) { Object }
    code_has_value?(code_value)
  when "invert"
    sig(args)
    code_invert
  when "keep_if"
    sig(args) { Function | Class }
    code_keep_if(code_value, **globals)
  when "keep_unless"
    sig(args) { Function | Class }
    code_keep_unless(code_value, **globals)
  when "key"
    sig(args) { [Object, Function.maybe] }
    code_key(*code_arguments.raw, **globals)
  when "keys"
    sig(args)
    code_keys
  when "merge"
    sig(args) { [Dictionary.repeat, Function.maybe] }
    code_merge(*code_arguments.raw, **globals)
  when "merge!"
    sig(args) { [Dictionary.repeat, Function.maybe] }
    code_merge!(*code_arguments.raw, **globals)
  when "select!", "filter!"
    sig(args) { Function | Class }
    code_select!(code_value, **globals)
  when "select", "filter"
    sig(args) { Function | Class }
    code_select(code_value, **globals)
  when "size"
    sig(args)
    code_size
  when "transform_values"
    sig(args) { Function }
    code_transform_values(code_value, **globals)
  when "to_query"
    sig(args) { String.maybe }
    code_to_query(code_value)
  when "values"
    sig(args)
    code_values
  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?
  when ->(code_operator) { code_has_key?(code_operator).truthy? }
    result = code_fetch(code_operator)

    if result.is_a?(Function)
      result.call(**args, operator: nil)
    else
      sig(args)
      result
    end
  else
    super
  end
end

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

Returns:

• (Boolean)

# File 'lib/code/object/dictionary.rb', line 570

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

  if code_argument.nothing?
    Boolean.new(raw.any?)
  elsif code_argument.is_a?(Class)
    Boolean.new(raw.any? { |_, value| value.is_a?(code_argument.raw) })
  else
    index = 0

    Boolean.new(
      raw.any? do |key, value|
        code_argument
          .call(
            arguments: List.new([key, value, Integer.new(index), self]),
            **globals
          )
          .truthy?
          .tap { index += 1 }
      end
    )
  end
end

#code_clear ⇒ Object

# File 'lib/code/object/dictionary.rb', line 594

def code_clear
  self.raw = {}
  self
end

#code_compact ⇒ Object

# File 'lib/code/object/dictionary.rb', line 599

def code_compact
  Dictionary.new(raw.dup.delete_if { |_, value| value.falsy? })
end

#code_compact! ⇒ Object

# File 'lib/code/object/dictionary.rb', line 603

def code_compact!
  raw.delete_if { |_, value| value.falsy? }
  self
end

#code_compare(other) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 608

def code_compare(other)
  code_other = other.to_code
  Integer.new(raw <=> code_other.raw)
end

#code_deep_duplicate ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1056

def code_deep_duplicate
  Dictionary.new(
    raw.dup.to_h { |key, value| [key, value].map(&:code_deep_duplicate) }
  )
end

#code_delete(*arguments, index: 0, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 613

def code_delete(*arguments, index: 0, **globals)
  arguments = arguments.to_code.raw
  code_index = index.to_code

  code_default =
    (
      arguments.last if arguments.last.is_a?(Function) && arguments.many?
    ).to_code

  arguments = arguments[...-1] unless code_default.nothing?
  code_first = arguments.first.to_code

  if arguments.one?
    raw.delete(code_first) do
      if code_default.nothing?
        Nothing.new
      else
        code_default.call(
          arguments: List.new([code_first, code_index, self]),
          **globals
        )
      end
    end
  else
    Dictionary.new(
      arguments
        .map
        .with_index do |code_argument, index|
          if code_default.nothing?
            [
              code_argument,
              code_delete(code_argument, index: index, **globals)
            ]
          else
            [
              code_argument,
              code_delete(
                code_argument,
                code_default,
                index: index,
                **globals
              )
            ]
          end
        end
        .to_h
    )
  end
end

#code_delete_if(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 663

def code_delete_if(argument, **globals)
  code_argument = argument.to_code

  if code_argument.is_a?(Class)
    raw.delete_if { |_, value| value.is_a?(code_argument.raw) }
  else
    raw.delete_if.with_index do |(code_key, code_value), index|
      argument.call(
        arguments:
          List.new([code_key, code_value, Integer.new(index), self]),
        **globals
      ).truthy?
    end
  end

  self
end

#code_delete_unless(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 681

def code_delete_unless(argument, **globals)
  code_argument = argument.to_code

  if code_argument.is_a?(Class)
    raw.delete_if { |_, value| !value.is_a?(code_argument.raw) }
  else
    raw.delete_if.with_index do |(key, value), index|
      code_argument.call(
        arguments: List.new([key, value, Integer.new(index), self]),
        **globals
      ).falsy?
    end
  end

  self
end

#code_dig(*arguments) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 698

def code_dig(*arguments)
  code_arguments = arguments.to_code

  code_arguments
    .raw
    .reduce(self) do |code_acc, code_element|
      if code_acc.is_a?(Dictionary) || code_acc.is_a?(List)
        code_acc.code_get(code_element)
      else
        Nothing.new
      end
    end
end

#code_each(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 712

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

  raw.each.with_index do |(key, value), index|
    code_argument.call(
      arguments: List.new([key, value, Integer.new(index), self]),
      **globals
    )
  end

  self
end

#code_empty? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/code/object/dictionary.rb', line 725

def code_empty?
  Boolean.new(raw.empty?)
end

#code_except(*arguments) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 729

def code_except(*arguments)
  code_arguments = arguments.to_code
  Dictionary.new(raw.except(*code_arguments.raw))
end

#code_fetch(*arguments, index: 0, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 734

def code_fetch(*arguments, index: 0, **globals)
  code_index = index.to_code
  arguments = arguments.to_code.raw

  code_default =
    (
      arguments.last if arguments.last.is_a?(Function) && arguments.many?
    ).to_code

  arguments = arguments[..-2] unless code_default.nothing?
  code_first = arguments.first.to_code

  if arguments.one?
    raw.fetch(code_first) do
      if code_default.nothing?
        Nothing.new
      else
        code_default.call(
          arguments: List.new([code_first, code_index, self]),
          **globals
        )
      end
    end
  else
    Dictionary.new(
      arguments
        .map
        .with_index do |code_argument, index|
          if code_default.nothing?
            [
              code_argument,
              code_fetch(code_argument, index: index, **globals)
            ]
          else
            [
              code_argument,
              code_fetch(
                code_argument,
                code_default,
                index: index,
                **globals
              )
            ]
          end
        end
        .to_h
    )
  end
end

#code_fetch_values(*arguments) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 784

def code_fetch_values(*arguments)
  code_arguments = arguments.to_code

  List.new(raw.fetch_values(*code_arguments.raw))
end

#code_flatten(level = nil) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 790

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

#code_get(key) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 796

def code_get(key)
  code_key = key.to_code
  raw[code_key] || Nothing.new
end

#code_has_key?(key) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/code/object/dictionary.rb', line 801

def code_has_key?(key)
  code_key = key.to_code
  Boolean.new(raw.key?(code_key))
end

#code_has_value?(key) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/code/object/dictionary.rb', line 806

def code_has_value?(key)
  code_key = key.to_code
  Boolean.new(raw.value?(code_key))
end

#code_inferior(other) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 811

def code_inferior(other)
  code_other = other.to_code
  Boolean.new(raw < code_other.raw)
end

#code_inferior_or_equal(other) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 816

def code_inferior_or_equal(other)
  code_other = other.to_code
  Boolean.new(raw <= code_other.raw)
end

#code_invert ⇒ Object

# File 'lib/code/object/dictionary.rb', line 821

def code_invert
  Dictionary.new(raw.invert)
end

#code_keep_if(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 825

def code_keep_if(argument, **globals)
  code_argument = argument.to_code

  if code_argument.is_a?(Class)
    raw.keep_if { |_, value| value.is_a?(code_argument.raw) }
  else
    raw.keep_if.with_index do |(key, value), index|
      code_argument.call(
        arguments: List.new([key, value, Integer.new(index), self]),
        **globals
      ).truthy?
    end
  end

  self
end

#code_keep_unless(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 842

def code_keep_unless(argument, **globals)
  code_argument = argument.to_code

  if code_argument.is_a?(Class)
    raw.keep_if { |_, value| !value.is_a?(code_argument.raw) }
  else
    raw.keep_if.with_index do |(key, value), index|
      code_argument.call(
        arguments: List.new([key, value, Integer.new(index), self]),
        **globals
      ).falsy?
    rescue Error::Next => e
      e.code_value.falsy?
    end
  end

  self
end

#code_key(value, function = nil, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 861

def code_key(value, function = nil, **globals)
  code_value = value.to_code
  code_function = function.to_code

  if code_function.nothing?
    raw.key(code_value) || Nothing.new
  else
    raw.key(code_value) ||
      function.call(arguments: List.new([code_value, self]), **globals)
  end
rescue Error::Next => e
  e.code_value
end

#code_keys ⇒ Object

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

def code_keys
  List.new(raw.keys)
end

#code_merge(*arguments, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 879

def code_merge(*arguments, **globals)
  arguments = arguments.to_code.raw

  code_conflict =
    (
      arguments.last if arguments.last.is_a?(Function) && arguments.many?
    ).to_code

  arguments = arguments[..-2] unless code_conflict.nothing?

  index = 0

  Dictionary.new(
    raw.merge(*arguments.map(&:raw)) do |key, old_value, new_value|
      if code_conflict.nothing?
        new_value.to_code.tap { index += 1 }
      else
        code_conflict
          .call(
            arguments:
              List.new(
                [
                  key.to_code,
                  old_value.to_code,
                  new_value.to_code,
                  index.to_code,
                  self
                ]
              ),
            **globals
          )
          .tap { index += 1 }
      end
    rescue Error::Next => e
      e.code_value.tap { index += 1 }
    end
  )
end

#code_merge!(*arguments, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 918

def code_merge!(*arguments, **globals)
  arguments = arguments.to_code.raw

  code_conflict =
    (
      arguments.last if arguments.last.is_a?(Function) && arguments.many?
    ).to_code

  arguments = arguments[..-2] unless code_conflict.nothing?

  index = 0

  raw.merge!(*arguments.map(&:raw)) do |key, old_value, new_value|
    if code_conflict.nothing?
      new_value.to_code.tap { index += 1 }
    else
      code_conflict
        .call(
          arguments:
            List.new(
              [
                key.to_code,
                old_value.to_code,
                new_value.to_code,
                index.to_code,
                self
              ]
            ),
          **globals
        )
        .tap { index += 1 }
    end
  rescue Error::Next => e
    e.code_value.tap { index += 1 }
  end

  self
end

#code_select(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 977

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

  if code_argument.is_a?(Class)
    Dictionary.new(
      raw.select { |_, value| value.is_a?(code_argument.raw) }
    )
  else
    Dictionary.new(
      raw.select.with_index do |(key, value), index|
        argument.call(
          arguments:
            List.new([key.to_code, value.to_code, index.to_code, self]),
          **globals
        ).truthy?
      rescue Error::Next => e
        e.code_value.truthy?
      end
    )
  end
end

#code_select!(argument, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 957

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

  if code_argument.is_a?(Class)
    raw.select! { |_, value| value.is_a?(code_argument.raw) }
  else
    raw.select!.with_index do |(key, value), index|
      argument.call(
        arguments:
          List.new([key.to_code, value.to_code, index.to_code, self]),
        **globals
      ).truthy?
    rescue Error::Next => e
      e.code_value.truthy?
    end
  end

  self
end

#code_set(key, value) ⇒ Object

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

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

#code_size ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1006

def code_size
  Integer.new(raw.size)
end

#code_superior(other) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1010

def code_superior(other)
  code_other = other.to_code
  Boolean.new(raw > code_other.raw)
end

#code_superior_or_equal(other) ⇒ Object

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

def code_superior_or_equal(other)
  code_other = other.to_code
  Boolean.new(raw >= code_other.raw)
end

#code_to_context ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1020

def code_to_context
  Context.new(raw)
end

#code_to_query(namespace = nil) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1024

def code_to_query(namespace = nil)
  code_namespace = namespace.to_code

  String.new(raw.to_query(code_namespace.raw))
end

#code_transform_values(function, **globals) ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1030

def code_transform_values(function, **globals)
  code_function = function.to_code

  Dictionary.new(
    raw
      .map
      .with_index do |(key, value), index|
        [
          key.to_code,
          code_function.call(
            arguments:
              List.new([key.to_code, value.to_code, index.to_code, self]),
            **globals
          )
        ]
      rescue Error::Next => e
        [key.to_code, e.code_value]
      end
      .to_h
  )
end

#code_values ⇒ Object

# File 'lib/code/object/dictionary.rb', line 1052

def code_values
  List.new(raw.values)
end