fn pub static new(input: I) -> PemFile[I, E] {
  PemFile(
    input: BufferedReader.new(input),
    line: 1,
    buffer: ByteArray.new,
    decoder: Decoder.new,
  )
}

fn pub mut all?(func: fn (T) -> Bool) -> Bool {
  loop {
    match self.next {
      case Some(v) -> if !func.call(v) { return false }
      case _ -> return true
    }
  }
}

fn pub mut any?(func: fn (T) -> Bool) -> Bool {
  loop {
    match self.next {
      case Some(v) -> if func.call(v) { return true }
      case _ -> return false
    }
  }
}

fn pub move chain[I: mut + Iter[T]](other: I) -> Stream[T] {
  let mut iter_left = true

  Stream.new(fn move {
    if iter_left {
      let item = self.next

      if item.some? { return item } else { iter_left = false }
    }

    other.next
  })
}

fn pub move chunks(size: Int) -> Stream[Array[T]] {
  Stream.new(fn move {
    let chunk = []

    while chunk.size < size {
      match self.next {
        case Some(val) -> chunk.push(val)
        case _ -> break
      }
    }

    if chunk.empty? { Option.None } else { Option.Some(chunk) }
  })
}

fn pub move count -> Int {
  reduce(0, fn (count, _) { count + 1 })
}

fn pub mut find(func: fn (ref T) -> Bool) -> Option[T] {
  loop {
    match self.next {
      case Some(v) -> if func.call(v) { return Option.Some(v) }
      case _ -> return Option.None
    }
  }
}

fn pub mut find_map[R](func: fn (T) -> Option[R]) -> Option[R] {
  loop {
    match self.next {
      case Some(v) -> {
        match func.call(v) {
          case Some(r) -> return Option.Some(r)
          case _ -> {}
        }
      }
      case _ -> return Option.None
    }
  }
}

fn pub move flat_map[V, I: mut + Iter[V]](func: fn (T) -> I) -> Stream[V] {
  let mut iter_opt: Option[I] = Option.None

  Stream.new(fn move {
    loop {
      match iter_opt.as_mut {
        case Some(v) -> {
          match v.next {
            case Some(v) -> return Option.Some(v)
            case _ -> {}
          }
        }
        case _ -> {}
      }

      match self.next {
        case Some(v) -> iter_opt = Option.Some(func.call(v))
        case _ -> return Option.None
      }
    }
  })
}

fn pub move into_iter -> Self {
  self
}

fn pub move last -> Option[T] {
  reduce(Option.None, fn (_, val) { Option.Some(val) })
}

fn pub move map[R](func: fn (T) -> R) -> Stream[R] {
  Stream.new(fn move { self.next.map(fn (v) { func.call(v) }) })
}

fn pub mut next -> Option[Result[Item, ParseError[E]]] {
  match parse {
    case Ok(Some(v)) -> Option.Some(Result.Ok(v))
    case Ok(_) -> Option.None
    case Error(e) -> Option.Some(Result.Error(e))
  }
}

fn pub mut next_certificate -> Result[Option[Certificate], ParseError[E]] {
  loop {
    match parse {
      case Ok(Some(Certificate(v))) -> return Result.Ok(Option.Some(v))
      case Ok(Some(_)) -> {}
      case Error(e) -> throw e
      case _ -> return Result.Ok(Option.None)
    }
  }
}

fn pub mut next_private_key -> Result[Option[PrivateKey], ParseError[E]] {
  loop {
    match parse {
      case Ok(Some(PrivateKey(v))) -> return Result.Ok(Option.Some(v))
      case Ok(Some(_)) -> {}
      case Error(e) -> throw e
      case _ -> return Result.Ok(Option.None)
    }
  }
}

fn pub move partition(func: fn (ref T) -> Bool) -> (Array[T], Array[T]) {
  reduce(([], []), fn move (acc, val) {
    if func.call(ref val) { acc.0.push(val) } else { acc.1.push(val) }

    acc
  })
}

fn pub move peekable -> Peekable[T, Self] {
  Peekable(iter: self, peeked: Option.None)
}

fn pub move reduce[A](accumulator: A, func: fn (A, T) -> A) -> A {
  let mut result = accumulator

  loop {
    match self.next {
      case Some(v) -> result = func.call(result, v)
      case _ -> return result
    }
  }
}

fn pub move select(func: fn (ref T) -> Bool) -> Stream[T] {
  Stream.new(fn move {
    loop {
      match self.next {
        case Some(v) -> if func.call(v) { return Option.Some(v) }
        case _ -> return Option.None
      }
    }
  })
}

fn pub move select_map[R](func: fn (T) -> Option[R]) -> Stream[R] {
  Stream.new(fn move {
    loop {
      match self.next {
        case Some(v) -> {
          match func.call(v) {
            case Some(r) -> return Option.Some(r)
            case _ -> next
          }
        }
        case _ -> return Option.None
      }
    }
  })
}

fn pub move skip(amount: Int) -> Stream[T] {
  let mut pending = amount

  Stream.new(fn move {
    while pending > 0 {
      match self.next {
        case Some(_) -> pending -= 1
        case _ -> break
      }
    }

    self.next
  })
}

fn pub move skip_while(func: fn (ref T) -> Bool) -> Stream[T] {
  let mut skip = true

  Stream.new(fn move {
    while skip {
      match self.next {
        case Some(v) if func.call(v) -> {}
        case Some(v) -> {
          skip = false
          return Option.Some(v)
        }
        case _ -> return Option.None
      }
    }

    self.next
  })
}

fn pub move take(amount: Int) -> Stream[T] {
  let mut pending = amount

  Stream.new(fn move {
    if (pending := pending - 1) > 0 { self.next } else { Option.None }
  })
}

fn pub move take_while(func: fn (ref T) -> Bool) -> Stream[T] {
  let mut take = true

  Stream.new(fn move {
    if take {
      match self.next {
        case Some(v) if func.call(v) -> Option.Some(v)
        case Some(_) -> {
          take = false
          Option.None
        }
        case _ -> Option.None
      }
    } else {
      Option.None
    }
  })
}

fn pub move to_array -> Array[T] {
  reduce([], fn (values, value) {
    values.push(value)
    values
  })
}

fn pub mut try_reduce[A, E](
  accumulator: A,
  func: fn (A, T) -> Result[A, E],
) -> Result[A, E] {
  let mut result = accumulator

  loop {
    match self.next {
      case Some(v) -> result = try func.call(result, v)
      case _ -> return Result.Ok(result)
    }
  }
}

fn pub move with_index -> Stream[(Int, T)] {
  let mut index = 0

  map(fn move (val) { (index := index + 1, val) })
}

fn pub move zip[U, I: mut + Iter[U]](other: I) -> Stream[(T, U)] {
  Stream.new(fn move { self.next.zip(other.next) })
}