module Hamster

def self.hash(pairs = {}, &block)
  Hash.new(pairs, &block)
end

def self.mutable_hash(pairs = {}, &block)
  MutableHash.new(hash(pairs, &block))
end

def self.mutable_queue(*items)
  MutableQueue.new(queue(*items))
end

def self.mutable_set(*items)
  MutableSet.new(set(*items))
end

def self.mutable_stack(*items)
  MutableStack.new(stack(*items))
end

def self.queue(*items)
  items.reduce(EmptyQueue) { |queue, item| queue.enqueue(item) }
end

def self.set(*items)
  items.reduce(EmptySet) { |set, item| set.add(item) }
end

def self.stack(*items)
  items.reduce(EmptyStack) { |stack, item| stack.push(item) }
end

def self.vector(*items)
  items.reduce(EmptyVector) { |vector, item| vector.add(item) }
end

def enumerate(enum)
  Stream.new do
    begin
      Sequence.new(enum.next, enumerate(enum))
    rescue StopIteration
      EmptyList
    end
  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
  Stream.new { Sequence.new(from, interval_exclusive(from.next, to)) }
end

def iterate(item, &block)
  Stream.new { Sequence.new(item, iterate(yield(item), &block)) }
end

def list(*items)
  items.to_list
end

def repeat(item)
  Stream.new { Sequence.new(item, repeat(item)) }
end

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

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