module Hamster

def enumerate(enum)
  LazyList.new do
    begin
      Cons.new(enum.next, enumerate(enum))
    rescue StopIteration
      EmptyList
    end
  end
end

def from(obj)
  case obj
  when ::Hash
    res = obj.map { |key, value| [from(key), from(value)] }
    Hamster::Hash.new(res)
  when Hamster::Hash
    obj.map { |key, value| [from(key), from(value)] }
  when ::Struct
    from(obj.to_h)
  when ::Array
    res = obj.map { |element| from(element) }
    Hamster::Vector.new(res)
  when ::SortedSet
    # This clause must go before ::Set clause, since ::SortedSet is a ::Set.
    res = obj.map { |element| from(element) }
    Hamster::SortedSet.new(res)
  when ::Set
    res = obj.map { |element| from(element) }
    Hamster::Set.new(res)
  when Hamster::Vector, Hamster::Set, Hamster::SortedSet
    obj.map { |element| from(element) }
  else
    obj
  end
end

def interval(from, to)
  return EmptyList if from > to
  interval_exclusive(from, to.next)
end

def interval_exclusive(from, to)
  return EmptyList if from == to
  LazyList.new { Cons.new(from, interval_exclusive(from.next, to)) }
end

def iterate(item, &block)
  LazyList.new { Cons.new(item, iterate(yield(item), &block)) }
end

def repeat(item)
  LazyList.new { Cons.new(item, repeat(item)) }
end

def replicate(number, item)
  repeat(item).take(number)
end

def stream(&block)
  return EmptyList unless block_given?
  LazyList.new { Cons.new(yield, stream(&block)) }
end

def to_ruby(obj)
  case obj
  when Hamster::Hash, ::Hash
    obj.each_with_object({}) { |keyval, hash| hash[to_ruby(keyval[0])] = to_ruby(keyval[1]) }
  when Hamster::Vector, ::Array
    obj.each_with_object([]) { |element, arr| arr << to_ruby(element) }
  when Hamster::Set, ::Set
    obj.each_with_object(::Set.new) { |element, set| set << to_ruby(element) }
  when Hamster::SortedSet, ::SortedSet
    obj.each_with_object(::SortedSet.new) { |element, set| set << to_ruby(element) }
  when Hamster::Deque
    obj.to_a.tap { |arr| arr.map! { |element| to_ruby(element) }}
  else
    obj
  end
end