module Refinements::Hash

Provides additional enhancements to the Hash primitive.

Public Instance Methods

compress(= compact.delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }) click to toggle source
# File lib/refinements/hash.rb, line 17
def compress = compact.delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }

def compress!
  delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }
  compact!
end

def deep_merge other
  clazz = self.class

  merge other do |_key, this_value, other_value|
    if this_value.is_a?(clazz) && other_value.is_a?(clazz)
      this_value.deep_merge other_value
    else
      other_value
    end
  end
end

def deep_merge!(other) = replace(deep_merge(other))

def deep_stringify_keys = recurse(&:stringify_keys)

def deep_stringify_keys! = replace(deep_stringify_keys)

def deep_symbolize_keys = recurse(&:symbolize_keys)

def deep_symbolize_keys! = replace(deep_symbolize_keys)

def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end

def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end

def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end

def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| 
compress!() click to toggle source
# File lib/refinements/hash.rb, line 19
def compress!
  delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }
  compact!
end
deep_merge(other) click to toggle source
# File lib/refinements/hash.rb, line 24
def deep_merge other
  clazz = self.class

  merge other do |_key, this_value, other_value|
    if this_value.is_a?(clazz) && other_value.is_a?(clazz)
      this_value.deep_merge other_value
    else
      other_value
    end
  end
end
deep_merge!(other) click to toggle source
# File lib/refinements/hash.rb, line 36
def deep_merge!(other) = replace(deep_merge(other))

def deep_stringify_keys = recurse(&:stringify_keys)

def deep_stringify_keys! = replace(deep_stringify_keys)

def deep_symbolize_keys = recurse(&:symbolize_keys)

def deep_symbolize_keys! = replace(deep_symbolize_keys)

def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end

def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end

def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end

def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.
deep_stringify_keys(= recurse(&:stringify_keys)) click to toggle source
# File lib/refinements/hash.rb, line 38
def deep_stringify_keys = recurse(&:stringify_keys)

def deep_stringify_keys! = replace(deep_stringify_keys)

def deep_symbolize_keys = recurse(&:symbolize_keys)

def deep_symbolize_keys! = replace(deep_symbolize_keys)

def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end

def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end

def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end

def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size 
deep_stringify_keys!(= replace(deep_stringify_keys)) click to toggle source
# File lib/refinements/hash.rb, line 40
def deep_stringify_keys! = replace(deep_stringify_keys)

def deep_symbolize_keys = recurse(&:symbolize_keys)

def deep_symbolize_keys! = replace(deep_symbolize_keys)

def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end

def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end

def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end

def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size == 
deep_symbolize_keys(= recurse(&:symbolize_keys)) click to toggle source
# File lib/refinements/hash.rb, line 42
def deep_symbolize_keys = recurse(&:symbolize_keys)

def deep_symbolize_keys! = replace(deep_symbolize_keys)

def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end

def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end

def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end

def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size == 2 
deep_symbolize_keys!(= replace(deep_symbolize_keys)) click to toggle source
# File lib/refinements/hash.rb, line 44
def deep_symbolize_keys! = replace(deep_symbolize_keys)

def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end

def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end

def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end

def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size == 2 }
diff(other) click to toggle source
# File lib/refinements/hash.rb, line 46
def diff other
  return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

  each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
end
differences_from(other) click to toggle source
# File lib/refinements/hash.rb, line 106
def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size == 2 }
end
fetch_value(key, *default, &) { || ... } click to toggle source
# File lib/refinements/hash.rb, line 52
def fetch_value(key, *default, &)
  fetch(key, *default, &) || (yield if block_given?) || default.first
end
flatten_keys(prefix: nil, delimiter: "_") click to toggle source
# File lib/refinements/hash.rb, line 56
def flatten_keys prefix: nil, delimiter: "_"
  reduce({}) do |accumulator, (key, value)|
    flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

    next accumulator.merge flat_key => value unless value.is_a? ::Hash

    accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
  end
end
flatten_keys!(prefix: nil, delimiter: "_") click to toggle source
# File lib/refinements/hash.rb, line 66
def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end

def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size == 2 }
end
infinite(= new { |nascence, lacuna| nascence[lacuna] = new(&nascence.default_proc) }) click to toggle source
# File lib/refinements/hash.rb, line 9
  def infinite = new { |nascence, lacuna| nascence[lacuna] = new(&nascence.default_proc) }

  def with_default(value) = new { |nascence, lacuna| nascence[lacuna] = value }
end

refine ::Hash do
  import_methods Shared::Many

  def compress = compact.delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }

  def compress!
    delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }
    compact!
  end

  def deep_merge other
    clazz = self.class

    merge other do |_key, this_value, other_value|
      if this_value.is_a?(clazz) && other_value.is_a?(clazz)
        this_value.deep_merge other_value
      else
        other_value
      end
    end
  end

  def deep_merge!(other) = replace(deep_merge(other))

  def deep_stringify_keys = recurse(&:stringify_keys)

  def deep_stringify_keys! = replace(deep_stringify_keys)

  def deep_symbolize_keys = recurse(&:symbolize_keys)

  def deep_symbolize_keys! = replace(deep_symbolize_keys)

  def diff other
    return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!

    each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
  end

  def fetch_value(key, *default, &)
    fetch(key, *default, &) || (yield if block_given?) || default.first
  end

  def flatten_keys prefix: nil, delimiter: "_"
    reduce({}) do |accumulator, (key, value)|
      flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key

      next accumulator.merge flat_key => value unless value.is_a? ::Hash

      accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
    end
  end

  def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)

  def recurse &block
    return self unless block

    transform = yield self
    transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
  end

  def stringify_keys = transform_keys(&:to_s)

  def stringify_keys! = transform_keys!(&:to_s)

  def symbolize_keys = transform_keys(&:to_sym)

  def symbolize_keys! = transform_keys!(&:to_sym)

  def transform_value(key, &) = dup.transform_value!(key, &)

  def transform_value! key
    block_given? && key?(key) ? merge!(key => yield(self[key])) : self
  end

  def transform_with(**) = dup.transform_with!(**)

  def transform_with!(**operations)
    operations.each { |key, function| self[key] = function.call self[key] if key? key }
    self
  end

  def use &block
    return [] unless block

    block.parameters
         .map { |(_type, key)| self[key] || self[key.to_s] }
         .then { |values| yield values }
  end

  private

  def differences_from other
    result = merge(other.to_h) { |_, one, two| [one, two].uniq }
    result.select { |_, diff
recurse() { |self| ... } click to toggle source
# File lib/refinements/hash.rb, line 68
def recurse &block
  return self unless block

  transform = yield self
  transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
end
stringify_keys(= transform_keys(&:to_s)) click to toggle source
# File lib/refinements/hash.rb, line 75
def stringify_keys = transform_keys(&:to_s)

def stringify_keys! = transform_keys!(&:to_s)

def symbolize_keys = transform_keys(&:to_sym)

def symbolize_keys! = transform_keys!(&:to_sym)

def transform_value(key, &) = dup.transform_value!(key, &)

def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end

def transform_with(**) = dup.transform_with!(**)

def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end

def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end

private

def differences_from other
  result = merge(other.to_h) { |_, one, two| [one, two].uniq }
  result.select { |_, diff| diff.size == 2 }
end
    
stringify_keys!(= transform_keys!(&:to_s)) click to toggle source
# File lib/refinements/hash.rb, line 77
  def stringify_keys! = transform_keys!(&:to_s)

  def symbolize_keys = transform_keys(&:to_sym)

  def symbolize_keys! = transform_keys!(&:to_sym)

  def transform_value(key, &) = dup.transform_value!(key, &)

  def transform_value! key
    block_given? && key?(key) ? merge!(key => yield(self[key])) : self
  end

  def transform_with(**) = dup.transform_with!(**)

  def transform_with!(**operations)
    operations.each { |key, function| self[key] = function.call self[key] if key? key }
    self
  end

  def use &block
    return [] unless block

    block.parameters
         .map { |(_type, key)| self[key] || self[key.to_s] }
         .then { |values| yield values }
  end

  private

  def differences_from other
    result = merge(other.to_h) { |_, one, two| [one, two].uniq }
    result.select { |_, diff| diff.size == 2 }
  end
end
symbolize_keys(= transform_keys(&:to_sym)) click to toggle source
# File lib/refinements/hash.rb, line 79
    def symbolize_keys = transform_keys(&:to_sym)

    def symbolize_keys! = transform_keys!(&:to_sym)

    def transform_value(key, &) = dup.transform_value!(key, &)

    def transform_value! key
      block_given? && key?(key) ? merge!(key => yield(self[key])) : self
    end

    def transform_with(**) = dup.transform_with!(**)

    def transform_with!(**operations)
      operations.each { |key, function| self[key] = function.call self[key] if key? key }
      self
    end

    def use &block
      return [] unless block

      block.parameters
           .map { |(_type, key)| self[key] || self[key.to_s] }
           .then { |values| yield values }
    end

    private

    def differences_from other
      result = merge(other.to_h) { |_, one, two| [one, two].uniq }
      result.select { |_, diff| diff.size == 2 }
    end
  end
end
symbolize_keys!(= transform_keys!(&:to_sym)) click to toggle source
# File lib/refinements/hash.rb, line 81
      def symbolize_keys! = transform_keys!(&:to_sym)

      def transform_value(key, &) = dup.transform_value!(key, &)

      def transform_value! key
        block_given? && key?(key) ? merge!(key => yield(self[key])) : self
      end

      def transform_with(**) = dup.transform_with!(**)

      def transform_with!(**operations)
        operations.each { |key, function| self[key] = function.call self[key] if key? key }
        self
      end

      def use &block
        return [] unless block

        block.parameters
             .map { |(_type, key)| self[key] || self[key.to_s] }
             .then { |values| yield values }
      end

      private

      def differences_from other
        result = merge(other.to_h) { |_, one, two| [one, two].uniq }
        result.select { |_, diff| diff.size == 2 }
      end
    end
  end
end
transform_value(key, &) click to toggle source
# File lib/refinements/hash.rb, line 83
    def transform_value(key, &) = dup.transform_value!(key, &)

    def transform_value! key
      block_given? && key?(key) ? merge!(key => yield(self[key])) : self
    end

    def transform_with(**) = dup.transform_with!(**)

    def transform_with!(**operations)
      operations.each { |key, function| self[key] = function.call self[key] if key? key }
      self
    end

    def use &block
      return [] unless block

      block.parameters
           .map { |(_type, key)| self[key] || self[key.to_s] }
           .then { |values| yield values }
    end

    private

    def differences_from other
      result = merge(other.to_h) { |_, one, two| [one, two].uniq }
      result.select { |_, diff| diff.size == 2 }
    end
  end
end
transform_value!(key) { |self| ... } click to toggle source
# File lib/refinements/hash.rb, line 85
def transform_value! key
  block_given? && key?(key) ? merge!(key => yield(self[key])) : self
end
transform_with(**) click to toggle source
# File lib/refinements/hash.rb, line 89
  def transform_with(**) = dup.transform_with!(**)

  def transform_with!(**operations)
    operations.each { |key, function| self[key] = function.call self[key] if key? key }
    self
  end

  def use &block
    return [] unless block

    block.parameters
         .map { |(_type, key)| self[key] || self[key.to_s] }
         .then { |values| yield values }
  end

  private

  def differences_from other
    result = merge(other.to_h) { |_, one, two| [one, two].uniq }
    result.select { |_, diff| diff.size == 2 }
  end
end
transform_with!(**operations) click to toggle source
# File lib/refinements/hash.rb, line 91
def transform_with!(**operations)
  operations.each { |key, function| self[key] = function.call self[key] if key? key }
  self
end
use() { |values| ... } click to toggle source
# File lib/refinements/hash.rb, line 96
def use &block
  return [] unless block

  block.parameters
       .map { |(_type, key)| self[key] || self[key.to_s] }
       .then { |values| yield values }
end
with_default(value) click to toggle source
# File lib/refinements/hash.rb, line 11
  def with_default(value) = new { |nascence, lacuna| nascence[lacuna] = value }
end