Emprunter des arguments en lecture seule

When you pass a value to a function, Mojo needs to know who can read or change it. That rule is an ownership convention. 🔑

By default an argument is borrowed. The function gets read access to the caller's value but does not take it over.

A borrowed argument is read-only inside the function. You can look at it freely, but Mojo will not let you change it.

Borrowing avoids copying the data. The function shares the caller's value as an immutable reference, which keeps things fast.

You can write borrowed before a parameter to be explicit, though it is already the default for an fn function.

Because borrowing is the default, you usually skip the keyword. This function reads its argument exactly the same way.

If you assign to a borrowed argument, the compiler stops you. That error is Mojo protecting the caller's value.

Because the function only reads, you can borrow the same value in many calls at once with no risk of a surprise change.

Borrowing shines when a value is large. You read a big struct without paying the cost of a full copy on every call.

After a borrowed call, the original variable is still valid and unchanged. The caller never lost ownership of its value.

Borrowing is Mojo's safe, efficient default: read access, no copy, no mutation. Reach for it whenever a function only needs to inspect data.

Let us test what a borrowed argument allows.

Borrowing is the default: the function reads the caller's value with no copy and no mutation. It is Mojo's safe, fast way to pass data. 🎯