fn pub inline static new(start: Int, end: Int) -> InclusiveRange {
  InclusiveRange(start: start, end: end)
}

fn pub !=(other: ref Self) -> Bool {
  !(self == other)
}

fn pub inline ==(other: InclusiveRange) -> Bool {
  @start == other.start and @end == other.end
}

fn pub inline clone -> InclusiveRange {
  InclusiveRange(start: @start, end: @end)
}

fn pub inline contains?(value: Int) -> Bool {
  @start <= value and value <= @end
}

fn pub inline end -> Int {
  @end
}

fn pub fmt(formatter: mut Formatter) {
  formatter.write('[')
  @start.fmt(formatter)
  formatter.write(' to ')
  @end.fmt(formatter)
  formatter.write(']')
}

fn pub hash[H: mut + Hasher](hasher: mut H) {
  @start.hash(hasher)
  @end.hash(hasher)
}

fn pub inline inclusive? -> Bool {
  true
}

fn pub move into_iter -> Stream[Int] {
  iter
}

fn pub iter -> Stream[Int] {
  let mut current = @start
  let end = @end

  Stream.new(fn move {
    if current <= end {
      Option.Some(current := current + 1)
    } else {
      Option.None
    }
  })
}

fn pub inline size -> Int {
  if @end >= @start { @end - @start + 1 } else { 0 }
}

fn pub inline start -> Int {
  @start
}