# Arrays and Slices in rust

## Arrays in Rust

An array is a fixed-size collection of elements of the same type. In Rust, arrays are defined using square brackets `[]`, and their length is known at compile time.

### Creating Arrays

Here are some examples of how to create arrays in Rust:

```rust
fn main() {
    let numbers: [u8; 5] = [1, 2, 3, 4, 5]; // An array of 5 integers
    let zeros: [u8; 4] = [0; 4]; // An array of 4 integers, all initialized to 0

    println!("{:?}", numbers); // Output: [1, 2, 3, 4, 5]
    println!("{:?}", zeros);   // Output: [0, 0, 0, 0]

    println!("{}", numbers.len()); // Output: 5
    println!("{}", zeros.len()); // Output: 4
}
```

As you can observe from the above code snippet `[u8; 5]` and `[u8; 4]` are two distinct types in rust.

Since the size of the arrays are known at compile time they are always stored in the process stack memory. If you want to store the array in heap memory then `Vec` is the go to type in most cases.

## Slices in Rust

Slice is a fat pointer with type `&[T]`, where `T` represents any arbitrary type. It is called a fat pointer because it contains the starting address of the array of memory and it's length. One can have a mutable slice `&mut [T]` as well.

## Creating Slices

Slices are not standalone and are often inferred from structures like array, Vec etc.,

```rust
fn main() {
    // Slicing an array
    let array = [1, 2, 3, 4, 5];
    let slice = &array[1..4]; // A slice of array from index 1 to 3
    println!("{:?}", slice); // Output: [2, 3, 4]

    // Slicing a Vec
    let vector = vec![1, 2, 3, 4, 5];
    let slice = &vector[1..4]; // A slice of vector from index 1 to 3
    println!("{:?}", slice); // Output: [2, 3, 4]

    // Slicing a String
    let string = String::from("Hello, world!");
    let slice = &string[0..5]; // A slice of string from index 0 to 4
    println!("{}", slice); // Output: Hello
}
```

Slices behave like arrays, because under the hood they are just a reference to an array, array enclosed in a Vec or a String etc.,

Looking up for an element or mutating an element at an index of a slice/array/vec works very similar to how these structures are used in common programming languages like c, java, javascript, python etc.,


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://bitcoin-dev-project.gitbook.io/rust-for-bitcoiners/curriculum/module_1/4_arrays_and_slices.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.