Files
pplus-web/mojo/corpus/manual/snippets/manual-errors-1.mojo
T
2026-10-05 03:03:38 +00:00

102 lines
3.1 KiB
Mojo

# These are equivalent
raise Error("file not found")
raise "file not found"
```
The string literal form is a convenience—the compiler automatically wraps it in
an `Error`.
By declaring `raises`, you tell Mojo that a function may raise an error:
```mojo
def read_file_fn(path: String) raises -> String:
if not path:
raise "path cannot be empty"
return "contents of " + path
```
:::tip
If you need structured error data—like separate fields for an error code and
description—or allocation-free errors for GPU kernels, see
[Typed errors](#typed-errors) later on this page. For most application code,
`Error` with a descriptive string message is all you need.
:::
## Handle an error
Mojo uses `try`/`except` to detect and handle errors. The full syntax is:
```mojo
try:
# Code that might raise an error
except e:
# Runs if an error occurs
else:
# Runs if no error occurs
finally:
# Always runs, regardless of outcome
```
You must include one or both of `except` and `finally`. The `else` clause is
optional.
### How each clause works
- `try` — Contains code that might raise an error. If no error occurs, the
entire block executes. If an error occurs, execution stops at the `raise`
point and continues with the `except` clause (if present) or the `finally`
clause.
- `except` — Runs only when an error occurs in the `try` block. If you
provide a variable name (`except e:`), the error is bound to that variable.
A `try` block can have only one `except` clause.
- `else` — Runs only when no error occurs in the `try` block. The `else`
clause is *skipped* if the `try` clause exits via `continue`, `break`, or
`return`.
- `finally` — Runs after the `try` and any `except` or `else` clause,
regardless of outcome. It executes even if another clause exits via
`continue`, `break`, `return`, or by raising a new error. Use `finally` to
release resources (such as file handles) that must be cleaned up regardless
of whether an error occurred.
### Example
The following example demonstrates all four clauses. The `process_record()`
function raises `Error` for different conditions, and the caller loops over
a list of IDs to exercise each clause:
```mojo title="handle_error.mojo"
def process_record(id: Int) raises -> String:
if id < 0:
raise Error("invalid record ID: must be non-negative")
if id > 999:
raise Error("record not found")
return String("record_", id)
def main() raises:
try:
for id in [5, 0, 1001, -3, 42]:
var result: String
try:
print()
print("try => id:", id)
if id == 0:
continue
result = process_record(id)
except e:
if "invalid" in String(e):
print("except => fatal:", e)
raise e
print("except => handled:", e)
else:
print("else => success:", result)
finally:
print("finally => done with id:", id)
except e:
print("\nre-raised error:", e)