class Hamster::Hash

def all?
  each { |key, value| return false unless yield(key, value) } if block_given?
  true
end

def any?
  return !empty? unless block_given?
  each { |key, value| return true if yield(key, value) }
  false
end

def delete(key)
  trie = @trie.delete(key)
  if trie.equal?(@trie)
    self
  else
    self.class.new(trie)
  end
end

def dup
  self
end

def each
  return self unless block_given?
  @trie.each { |entry| yield(entry.key, entry.value) }
end

def empty?
  @trie.empty?
end

def eql?(other)
  other.is_a?(self.class) && @trie.eql?(other.instance_eval{@trie})
end

def filter
  return self unless block_given?
  trie = @trie.filter { |entry| yield(entry.key, entry.value) }
  if trie.equal?(@trie)
    self
  else
    self.class.new(trie)
  end
end

def find
  return nil unless block_given?
  each { |key, value| return Tuple.new(key, value) if yield(key, value) }
  nil
end

def get(key)
  entry = @trie.get(key)
  return entry.value if entry
end

def has_key?(key)
  @trie.has_key?(key)
end

def initialize(trie = Trie.new)
  @trie = trie
end

def inspect
  "{#{reduce([]) { |memo, key, value| memo << "#{key.inspect} => #{value.inspect}"}.join(", ")}}"
end

def map
  return self unless block_given?
  return self if empty?
  self.class.new(@trie.reduce(Trie.new) { |trie, entry| trie.put(*yield(entry.key, entry.value)) })
end

def none?
  return empty? unless block_given?
  each { |key, value| return false if yield(key, value) }
  true
end

def put(key, value)
  self.class.new(@trie.put(key, value))
end

def reduce(memo)
  return memo unless block_given?
  @trie.reduce(memo) { |memo, entry| yield(memo, entry.key, entry.value) }
end

def remove
  return self unless block_given?
  filter { |key, value| !yield(key, value) }
end

def size
  @trie.size
end