How to Check Whether a Path Exists in Rust

By the end of this page, you will understand why try! (and ?) only works in functions that return Result-like types, how to check whether a path exists in Rust, and when to use Path::exists() versus fs::metadata(). You will also see how to convert file-system errors into a simple bool when that is all you need.

In Rust, many file-system operations can fail. A path might not exist, permissions may be denied, or the path may be invalid. Because of that, APIs such as fs::metadata() return a Result instead of a plain value.

use std::fs;

let result = fs::metadata("file.txt");

That result is:

• Ok(metadata) if Rust successfully read the file system metadata
• Err(error) if something went wrong

The try! macro was designed to make error propagation easier. If the result is Ok, it unwraps the value. If it is Err, it immediately returns that error from the current function.

That means try! only makes sense inside a function that itself returns a Result (or another compatible type). If your function returns bool, there is nowhere for the error to be propagated.

For a simple existence check, you usually do one of these:

1. Use Path::exists() when you only want or

Think of Result as a delivery box.

• Ok(value) means the box contains what you asked for
• Err(error) means the box contains a note explaining why delivery failed

try! is like saying: "If the box contains an error note, stop everything and send that note back to my caller."

That only works if your function is set up to send error notes back, which means it must return a Result.

A bool function is different. It only answers yes or no. It cannot carry an error note. So if you want only yes/no, you need to turn the Result into a boolean yourself.

For example:

• fs::metadata(path) gives you the box
• .is_ok() asks: "Did I get a real value instead of an error?"
• Path::new(path).exists() asks the same question in a more direct way

The two most common ways to check path existence in Rust are:

1. Using Path::exists()

use std::path::Path;

pub fn path_exists(path: &str) -> bool {
    Path::new(path).exists()
}

This is the clearest option when you only need a boolean.

2. Using fs::metadata()

use std::fs;

pub fn path_exists(path: &str) -> bool {
    fs::metadata(path).is_ok()
}

This works because metadata() returns a Result, and is_ok() converts it to true or false.

Checking whether it is a file

If you want to know whether the path exists is a regular file:

Consider this function:

use std::fs;

pub fn path_exists(path: &str) -> bool {
    fs::metadata(path).is_ok()
}

Now trace what happens for two inputs.

Case 1: The path exists

let exists = path_exists("Cargo.toml");

Step by step:

1. fs::metadata("Cargo.toml") runs
2. Rust asks the operating system for metadata about that path
3. Suppose the file exists
4. The function gets Ok(metadata)
5. .is_ok() is called on Ok(metadata)
6. .is_ok() returns true
7. path_exists returns true

Case 2: The path does not exist

Checking whether a path exists is common in many Rust programs.

Configuration loading

Before reading a config file, an app may check whether it exists:

use std::path::Path;

if Path::new("config.toml").exists() {
    println!("Config file found");
}

Creating files only when needed

A script may avoid overwriting an existing file:

use std::path::Path;

if !Path::new("report.txt").exists() {
    println!("Safe to create report.txt");
}

Validating user input

A CLI tool may verify a file path provided by the user:

use std::fs;

fn input_file_valid(path: &str) -> bool {
    match fs::metadata(path) {
        Ok(metadata) => metadata.is_file(),
        Err(_) => ,
    }
}

In real projects, developers usually choose between a simple boolean check and full error handling based on the situation.

Pattern: simple existence check

When the exact error does not matter:

use std::path::Path;

if Path::new("settings.json").exists() {
    // continue
}

This is common in scripts, setup code, and quick validation.

Pattern: guard clause

A function may return early if a required file is missing:

use std::path::Path;

fn load_if_present(path: &str) {
    if !Path::new(path).exists() {
        return;
    }

    println!("Loading {path}");
}

Pattern: keep the real error

Sometimes false is not enough. If the path fails because of permissions, you may want to know that.

use std::fs;
use std::io;

fn file_size(path: &)  io::<> {
      = fs::(path)?;
    (metadata.())
}

1. Using try! or ? in a function that returns bool

Broken example:

use std::fs;

fn path_exists(path: &str) -> bool {
    let metadata = fs::metadata(path)?;
    metadata.is_file()
}

Why it fails:

• ? can only return early from a function that returns Result, Option, or a compatible type
• A bool function cannot carry that error

Fix:

use std::fs;

fn path_exists(path: &str) -> bool {
    fs::metadata(path).is_ok()
}

2. Using assert! to produce a return value

use std::path::Path;
use std::fs;

Check whether a path exists

Path::new(path).exists()

Check whether metadata can be read

fs::metadata(path).is_ok()

Check whether a path is a file

match fs::metadata(path) {
    Ok(metadata) => metadata.is_file(),
    Err(_) => false,
}

Check whether a path is a directory

match fs::metadata(path) {
    Ok(metadata) => metadata.is_dir(),
    Err(_) => false,
}

Propagate errors instead of converting to bool

Why does try! require a Result return type in Rust?

Because try! returns early when an error occurs. The function must therefore be able to return that error, which means it needs a Result-compatible return type.

What is the easiest way to check if a path exists in Rust?

Use:

use std::path::Path;
Path::new(path).exists()

How do I check if a path is a file and not just an existing path?

Use fs::metadata() and then call is_file() on the returned metadata.

Should I use try! or ? in modern Rust?

Use ?. It is the modern, cleaner replacement for try!.

Why is assert!(metadata.is_file()) not returning bool?

Because assert! is a macro for enforcing conditions. It panics if false and returns if true. It does not return the boolean expression.

• Result — Related because file-system operations often return Result to represent success or failure.
• Option — Useful for comparing simple absence/presence handling with richer error handling.
• match — Commonly used to handle Ok and Err cases explicitly.
• ? operator — The modern way to propagate errors from Result values.
• std::path::Path — The main type used for working with file-system paths in Rust.
• std::fs::metadata — Returns metadata for a path and is useful when you need more than existence.
• is_file and is_dir — Important when you need to distinguish file types after confirming a path is accessible.
• Error handling in Rust — The bigger topic that explains why Rust does not silently ignore failures.