fn pub inline static new(path: String) -> Path {
  Path(path)
}

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

fn pub ==(other: ref Path) -> Bool {
  @path == other.to_string
}

fn pub absolute? -> Bool {
  absolute_path?(@path)
}

fn pub clone -> Path {
  Path.new(@path)
}

fn pub components -> Components {
  Components.new(self)
}

fn pub copy[T: ToString](to: ref T) -> Result[Int, Error] {
  sys.copy_file(@path, to.to_string)
}

fn pub create_directory -> Result[Nil, Error] {
  sys.create_directory(@path)
}

fn pub create_directory_all -> Result[Nil, Error] {
  # A common case is when all leading directories already exist, in which case
  # we can avoid the more expensive loop to create the intermediate
  # directories.
  match create_directory {
    case Ok(_) or Error(AlreadyExists) -> return Result.Ok(nil)
    case Error(NotFound) -> {}
    case Error(e) -> throw e
  }

  try components.try_reduce('', fn (leading, cur) {
    let path = join_strings(leading, cur.to_string)

    match sys.create_directory(path) {
      case Ok(_) or Error(AlreadyExists) -> Result.Ok(path)
      case Error(e) -> Result.Error(e)
    }
  })

  Result.Ok(nil)
}

fn pub directory -> Path {
  let buf = ByteArray.new
  let comp = Components.new(self).peekable
  let mut root = false

  loop {
    match comp.next {
      case Some('/') -> {
        root = true
        buf.append(SEPARATOR)
      }
      case Some(v) if comp.peek.some? -> {
        let any = !buf.empty?

        if any and root { root = false } else if any { buf.append(SEPARATOR) }

        buf.append(v)
      }
      case _ -> break
    }
  }

  if buf.empty? { Path.new('.') } else { Path.new(buf.into_string) }
}

fn pub directory? -> Bool {
  metadata.map(fn (m) { m.type.directory? }).or(false)
}

fn pub exists? -> Bool {
  metadata.ok?
}

fn pub expand -> Result[Path, Error] {
  if @path == HOME {
    return match home_directory {
      case Some(v) -> Result.Ok(v)
      case _ -> Result.Error(Error.NotFound)
    }
  }

  let mut target = @path

  match @path.strip_prefix(HOME_WITH_SEPARATOR) {
    case Some(tail) -> {
      target = match home_directory {
        case Some(v) -> join_strings(v.path, tail)
        case _ -> throw Error.NotFound
      }
    }
    case _ -> {}
  }

  sys.expand_path(target).map(fn (v) { Path.new(v) })
}

fn pub extension -> Option[Slice[String]] {
  let size = @path.size
  let mut min = match bytes_before_last_separator(@path) {
    case -1 -> 0
    case n -> n + 1
  }

  if min >= size { return Option.None }

  # If the name starts with a dot, we work our way backwards until the _next_
  # byte. This way we don't treat `.foo` as having the extension `foo`.
  if @path.get(min).or_panic == DOT_BYTE { min += 1 }

  let max = size - 1
  let mut idx = max

  # We consider something an extension if it has at least one non-dot byte,
  # meaning `foo.` is a path _without_ an extension. Different languages
  # handle this differently:
  #
  #     Language     Path      Extension    Leading dot included
  #     ---------------------------------------------------------
  #     Elixir       'foo.'    '.'          Yes
  #     Go           'foo.'    '.'          Yes
  #     Node.js      'foo.'    '.'          Yes
  #     Python       'foo.'    NONE         No
  #     Ruby         'foo.'    '.'          Yes
  #     Rust         'foo.'    NONE         No
  #     Vimscript    'foo.'    NONE         No
  #
  # Things get more inconsistent for paths such as `...`, with some treating
  # it as a file called `..` with the extension `.`, while others consider it
  # a path without an extension.
  while idx > min {
    if @path.get(idx).or_panic == DOT_BYTE { break } else { idx -= 1 }
  }

  if idx < max and idx > min {
    Option.Some(@path.slice(start: idx + 1, end: size))
  } else {
    Option.None
  }
}

fn pub file? -> Bool {
  metadata.map(fn (m) { m.type.file? }).or(false)
}

fn pub fmt(formatter: mut Formatter) {
  @path.fmt(formatter)
}

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

fn pub move into_string -> String {
  @path
}

fn pub join[T: ToString](path: ref T) -> Path {
  Path.new(join_strings(@path, with: path.to_string))
}

fn pub list -> Result[ReadDirectory, Error] {
  sys.ReadDirectory.new(@path).map(fn (inner) {
    ReadDirectory(path: @path, inner: inner)
  })
}

fn pub list_all -> Result[Stream[Result[DirectoryEntry, Error]], Error] {
  list.map(fn (iter) {
    let dirs = []
    let mut current = iter

    Stream.new(fn move {
      loop {
        match current.next {
          case Some(Ok({ @path = p, @type = Directory })) -> dirs.push(p)
          case Some(Ok(entry)) -> return Option.Some(Result.Ok(entry))
          case Some(Error(e)) -> return Option.Some(Result.Error(e))
          case None -> {
            match dirs.pop {
              case Some(dir) -> {
                match dir.list {
                  case Ok(iter) -> current = iter
                  case Error(e) -> return Option.Some(Result.Error(e))
                }
              }
              case _ -> return Option.None
            }
          }
        }
      }
    })
  })
}

fn pub metadata -> Result[Metadata, Error] {
  sys.path_metadata(@path)
}

fn pub relative? -> Bool {
  !absolute?
}

fn pub remove_directory -> Result[Nil, Error] {
  sys.remove_directory(@path)
}

fn pub remove_directory_all -> Result[Nil, Error] {
  let stack = [@path]
  let dirs = [@path]

  # First we remove all the files and gather the directories that need to be
  # removed.
  loop {
    let dir = match stack.pop {
      case Some(v) -> v
      case _ -> break
    }

    for entry in try sys.ReadDirectory.new(dir) {
      match entry {
        case Ok((name, Directory)) -> {
          let path = join_strings(dir, name)

          stack.push(path)
          dirs.push(path)
        }
        case Ok((name, _)) -> try sys.remove_file(join_strings(dir, name))
        case Error(e) -> throw e
      }
    }
  }

  # Now we can remove the directories in a depth-first order.
  loop {
    match dirs.pop {
      case Some(v) -> try sys.remove_directory(v)
      case _ -> break
    }
  }

  Result.Ok(nil)
}

fn pub remove_file -> Result[Nil, Error] {
  sys.remove_file(@path)
}

fn pub strip_prefix(prefix: ref Path) -> Option[Path] {
  let comp = components
  let valid = prefix.components.all?(fn (theirs) {
    match comp.next {
      case Some(ours) -> ours == theirs
      case _ -> false
    }
  })

  if valid {
    Option.Some(Path.new(String.join(comp, SEPARATOR)))
  } else {
    Option.None
  }
}

fn pub tail -> Slice[String] {
  let comp = Components.new(self)
  let mut start = -1
  let mut end = -1

  # This finds the range of the last component, taking into account path
  # normalization.
  while comp.index < comp.size {
    comp.advance_separator

    if comp.index < comp.size {
      start = comp.index
      end = start
    }

    while comp.index < comp.size and !comp.separator?(comp.index) {
      comp.index += 1
      end += 1
    }
  }

  if start == -1 { @path.slice(0, 0) } else { @path.slice(start, end: end) }
}

fn pub to_string -> String {
  @path
}

fn pub with_extension(name: String) -> Path {
  if name.contains?(SEPARATOR) {
    panic("file extensions can't contain path separators")
  }

  if @path.empty? { return clone }

  let raw = match extension {
    case Some(v) if name.empty? -> {
      @path.slice(start: 0, end: @path.size - v.size - 1).to_string
    }
    case Some(v) -> {
      '${@path.slice(start: 0, end: @path.size - v.size - 1)}.${name}'
    }
    case _ if name.empty? or @path.ends_with?(SEPARATOR) -> @path
    case _ -> '${@path}.${name}'
  }

  Path.new(raw)
}