I/O Types

// Open for reading
let file: Result#[File, IoError] = File.open("data.txt")

// Open for writing (creates or truncates)
let file: Result#[File, IoError] = File.create("output.txt")

// Open for appending
let file: Result#[File, IoError] = File.append("log.txt")

fn read_file_contents(path: string) -> Result#[string, IoError] {
    let file: File = File.open(path)?
    let contents: string = file.read_to_string()?
    file.close()
    return Ok(contents)
}

fn write_to_file(path: string, content: string) -> Result#[(), IoError] {
    let file: File = File.create(path)?
    file.write(content)?
    file.close()
    return Ok(())
}

fn copy_file(src: string, dst: string) -> Result#[(), IoError] {
    let content: string = File.open(src)?.read_to_string()?
    File.create(dst)?.write(content)?
    return Ok(())
}

fn read_line() -> Result#[string, IoError] {
    return Stdin.read_line()
}

fn main() -> i32 {
    print("Enter your name: ")
    let name: string = Stdin.read_line() ?? ""
    println("Hello, {name}!")
    return 0
}

fn main() -> i32 {
    Stdout.write("Hello, ")
    Stdout.write("World!")
    Stdout.write("\n")
    return 0
}

// More commonly, use println:
fn main() -> i32 {
    println("Hello, World!")
    return 0
}

fn log_error(message: string) -> void {
    Stderr.write("ERROR: ")
    Stderr.write(message)
    Stderr.write("\n")
}

let file: File = File.open("large_file.txt")?
let reader: BufReader = BufReader.new(file)

// Read line by line
while true {
    let line: ?string = reader.read_line()
    match line {
        Some(l) => { process_line(l) }
        None => { break }  // EOF
    }
}

let file: File = File.create("output.txt")?
let writer: BufWriter = BufWriter.new(file)

for i: i32 in 0..1000 {
    writer.write("Line {i}\n")
}

writer.flush()  // Ensure all data is written

enum IoError {
    NotFound,
    PermissionDenied,
    AlreadyExists,
    InvalidData,
    UnexpectedEof,
    Other(string),
}

fn read_config() -> Result#[string, string] {
    let result: Result#[File, IoError] = File.open("config.txt")

    match result {
        Ok(file) => {
            return file.read_to_string().map_err(|e: IoError| -> string {
                return "failed to read: {e}"
            })
        }
        Err(IoError.NotFound) => {
            return Err("config file not found")
        }
        Err(IoError.PermissionDenied) => {
            return Err("no permission to read config")
        }
        Err(e) => {
            return Err("unexpected error: {e}")
        }
    }
}

fn process_log_file(path: string) -> Result#[i32, IoError] {
    let file: File = File.open(path)?
    let reader: BufReader = BufReader.new(file)

    var error_count: i32 = 0

    loop {
        let line: ?string = reader.read_line()
        match line {
            Some(l) => {
                if l.contains("ERROR") {
                    error_count = error_count + 1
                    println("Found error: {l}")
                }
            }
            None => { break }
        }
    }

    reader.close()
    return Ok(error_count)
}

fn write_csv(path: string, data: List#[(string, i32)]) -> Result#[(), IoError] {
    let file: File = File.create(path)?
    let writer: BufWriter = BufWriter.new(file)

    // Write header
    writer.write("name,value\n")

    // Write data rows
    for (name, value) in data {
        writer.write("{name},{value}\n")
    }

    writer.flush()
    writer.close()
    return Ok(())
}

fn interactive_menu() -> i32 {
    loop {
        println("Menu:")
        println("1. Option A")
        println("2. Option B")
        println("3. Exit")
        print("Choice: ")

        let input: string = Stdin.read_line() ?? ""
        let choice: ?i32 = input.trim().to#[i32]

        match choice {
            Some(1) => { println("Selected A") }
            Some(2) => { println("Selected B") }
            Some(3) => { return 0 }
            _ => { println("Invalid choice") }
        }
        println("")
    }
}

let p: Path = Path.new("/home/user/documents")

let p: Path = Path.new("/home/user/file.txt")

// Convert to string
let s: string = p.to_string()  // "/home/user/file.txt"

// Join path components (handles trailing slashes correctly)
let joined: Path = p.join("subdir")  // "/home/user/file.txt/subdir"

// Get parent directory
let parent: ?Path = p.parent()  // Some(Path("/home/user"))

// Get filename
let name: ?string = p.file_name()  // Some("file.txt")

// Get extension
let ext: ?string = p.extension()  // Some("txt")

// Check existence and type
let exists: bool = p.exists()
let is_file: bool = p.is_file()
let is_dir: bool = p.is_dir()

// Check if path exists (file or directory)
let exists: bool = fs_exists("/path/to/file")

// Check if path is a file
let is_file: bool = fs_is_file("/path/to/file")

// Check if path is a directory
let is_dir: bool = fs_is_dir("/path/to/directory")

// Create a single directory
let result: Result#[void, IoError] = fs_create_dir("/path/to/new_dir")

// Create directory and all parent directories
let result: Result#[void, IoError] = fs_create_dir_all("/path/to/deep/nested/dir")

// Remove an empty directory
let result: Result#[void, IoError] = fs_remove_dir("/path/to/dir")

// Remove a file
let result: Result#[void, IoError] = fs_remove_file("/path/to/file")

// Read entire file as string
let content: Result#[String, IoError] = fs_read_string("/path/to/file.txt")

// Write string to file (creates or overwrites)
let result: Result#[void, IoError] = fs_write_string("/path/to/file.txt", "content")

let entries: Result#[List#[String], IoError] = fs_read_dir("/path/to/dir")

match entries {
    Ok(list) => {
        for name: String in list {
            println(name)
        }
        // IMPORTANT: You must manually clean up each string
        // before dropping the list. See ownership note below.
        list.drop()
    }
    Err(e) => {
        println("Error: {e}")
    }
}

// Good - handles potential failure
let file: File = File.open(path)?
// or
match File.open(path) {
    Ok(f) => { /* use f */ }
    Err(e) => { /* handle error */ }
}

// Bad - can panic
let file: File = File.open(path)!

fn process_file(path: string) -> Result#[(), IoError] {
    let file: File = File.open(path)?
    // ... do work ...
    file.close()  // Don't forget!
    return Ok(())
}

// Good for large files - efficient
let reader: BufReader = BufReader.new(File.open(path)?)
while let Some(line) = reader.read_line() {
    process(line)
}

// Less efficient for large files
let content: string = File.open(path)?.read_to_string()?