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

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

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

fn pub inline clone -> ExclusiveRange {
  ExclusiveRange(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(' until ')
  @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 {
  false
}

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 } else { 0 }
}

fn pub inline start -> Int {
  @start
}