Std.Io

47 public declarations

• appendStr -> Str -> Result[(), Str]

  Contents added to the end of a file, creating it when it is absent.

  fn
• appendAllBytesStr -> &Bytes -> Result[(), Std.Io.IoError]

  Add bytes after what a file already holds.

  fn
• appendLineStr -> Str -> Result[(), Str]

  A line added to the end of a file.

  fn
• classifiedStr -> Str -> Std.Io.IoError

  The cause an operating-system message names for a path, so other modules

  fn
• copyStr -> Str -> Result[(), Str]

  A file copied byte for byte, or a report of what stopped it.

  fn
• countBytesStr -> Result[Int, Std.Io.IoError]

  How many bytes a file holds, without holding any of them.

  fn
• directoryOfStr -> Str

  A path without its last piece, or `.` when it has only one.

  fn
• existsStr -> Bool

  Whether a path names something that exists.

  fn
• extensionOfStr -> Option[Str]

  A path's extension, without its dot, or nothing when it has none.

  fn
• foldChunks&Std.Io.Reader -> T -> fn(T, Bytes) -> T -> Result[T, Std.Io.IoError]

  Combine every chunk of a file into one value, holding one chunk at a time.

  fn
• foldLinesStr -> T -> fn(T, Str) -> T -> Result[T, Std.Io.IoError]

  Combine every line of a file into one value, holding one chunk at a time.

  fn
• forEachChunk&Std.Io.Reader -> fn(Bytes) -> () -> Result[(), Std.Io.IoError]

  Run an action for every chunk, keeping nothing.

  fn
• forEachLineStr -> fn(Str) -> () -> Result[(), Std.Io.IoError]

  Run an action for every line of a file, keeping nothing.

  fn
• IoError

  Why an operation over a file did not do what it was asked.

  type
• isSeparatorStr -> Bool

  Whether a character ends a piece of a path on this machine.

  fn
• joinStr -> Str -> Str

  Two path pieces joined with a separator, without doubling one.

  fn
• listStr -> Result[Array[Str], Str]

  The names a directory holds, without their paths.

  fn
• listPathsStr -> Result[Array[Str], Str]

  The paths a directory holds, each joined to the directory.

  fn
• makeDirectoryStr -> Result[(), Str]

  A directory created along with every parent it needs.

  fn
• moveStr -> Str -> Result[(), Str]

  A file moved by renaming it, copying only when a rename cannot reach.

  fn
• nameOfStr -> Str

  The last piece of a path.

  fn
• readStr -> Result[Str, Str]

  A file's whole contents.

  fn
• readAllBytesStr -> Result[Bytes, Std.Io.IoError]

  Every byte of a file, joined once rather than once per chunk.

  fn
• readAllLinesResult[Array[Str], Str]

  Every remaining line of input.

  fn
• readAllLinesOfStr -> Result[Array[Str], Std.Io.IoError]

  Every line of a file, in order.

  fn
• Reader

  A file open for reading, named by a token the runtime gave out.

  type
• readFrom&Std.Io.Reader -> Int -> Result[Option[Bytes], Std.Io.IoError]

  The next bytes from a reader, or nothing when the input has ended.

  fn
• readLineOrEndResult[Option[Str], Str]

  One line of input, or `None` at the end of it.

  fn
• readLinesStr -> Result[Array[Str], Str]

  A file's contents in lines.

  fn
• removeStr -> Result[(), Str]

  A file removed, or a report of why it could not be.

  fn
• removeIfPresentStr -> Result[(), Str]

  A file removed if it is there, and nothing done if it is not.

  fn
• separatorStr

  The path vocabulary, so a program reaching for it through `Std.Io` finds

  fn
• withAppenderStr -> fn(Std.Io.Writer) -> Result[T, Std.Io.IoError] -> Result[T, Std.Io.IoError]

  Write after what the file already holds.

  fn
• withExtensionStr -> Str -> Str

  A path carrying the given extension, replacing any it had.

  fn
• withoutExtensionStr -> Str

  A path with its extension removed.

  fn
• withReaderStr -> fn(Std.Io.Reader) -> Result[T, Std.Io.IoError] -> Result[T, Std.Io.IoError]

  Read a file through a handle the runtime owns for the length of the call.

  fn
• withWriterStr -> fn(Std.Io.Writer) -> Result[T, Std.Io.IoError] -> Result[T, Std.Io.IoError]

  Write a file the same way, replacing whatever it held.

  fn
• writeStr -> Str -> Result[(), Str]

  A file replaced with the given contents.

  fn
• writeAllBytesStr -> &Bytes -> Result[(), Std.Io.IoError]

  Write bytes to a file, replacing what it held.

  fn
• writeErrorLineStr -> Result[(), Str]

  A line written to the program's error output.

  fn
• writeFileLinesStr -> &Array[Str] -> Result[(), Str]

  Lines written to a file, each followed by a newline.

  fn
• writeLineStr -> Result[(), Str]

  A line written to the program's output.

  fn
• writeLines&Array[Str] -> Result[(), Str]

  Every line written in order, stopping at the first that fails.

  fn
• Writer

  A file open for writing.

  type
• writeTextTo&Std.Io.Writer -> Str -> Result[(), Std.Io.IoError]

  Write text through a writer, as its UTF-8 encoding.

  fn
• writeTo&Std.Io.Writer -> &Bytes -> Result[(), Std.Io.IoError]

  Write bytes through a writer.

  fn
• writeValueT -> Result[(), Str]

  Any value rendered and written as a line.

  fn