🦀 Axum - Hello World !

YellowCoder — Mon, 18 Mar 2024 20:41:15 +0000

Axum is a web application framework that focuses on ergonomics and modularity.

This yellowcoder-tibbit tells you about a simple Axum - “Hello World!” examples you can get quickly started with by following steps given in repo.

use axum::{response::Html, routing::get, Router};

#[tokio::main]
async fn main() {

    let app = Router::new().route("/",get(||async {
        Html("
            <h1>Hello World</h1>
            <h2>Here Rust Server is running....</h2>
            Author: <strong>Yellow Coder</strong>
            ")

    }));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();

    axum::serve(listener,app).await.unwrap();
}

GitRepo : https://github.com/shubhamlodhi/rusty-fork.git

Dereferencing Pointer in Rust

YellowCoder — Fri, 15 Mar 2024 11:27:09 +0000

Dereferencing refers to the process of accessing the value that a pointer or reference points to. It is done using the dereference operator *

//@yellowcoder  
//example #1

fn main(){

let x = 5;
let y = &x; // y is a reference to x

println!("{}", x);  // Prints: 5
println!("{}", y);  // Prints: 5  (automatically dereferenced)
println!("{}", *y); // Prints: 5  (explicitly dereferenced)

}

In the example above, x is the actual value (5), while y is a reference that points to the memory location where x is stored. When we try to print y directly, we get the memory address. To get the actual value 5, we need to dereference y using *y.

Dereferencing is necessary because Rust's ownership and borrowing rules are designed to ensure memory safety. References are just "views" into the actual data, and they don't own or control the data's lifetime. By requiring explicit dereferencing, Rust ensures that you are aware of when you're accessing the actual data through a reference, rather than the reference itself.

This explicit dereferencing helps catch potential bugs and promotes more readable and safer code, as it clearly distinguishes between working with references and working with the actual values they point to.

In summary, we need to dereference references in Rust to access the actual values they point to, as references themselves are just pointers to memory locations, not the values stored at those locations.

! Have a look on the below example 🧐

//@yellowcoder 
//example #2

fn example(z: &mut i32) {
    *z = 0;  // dereferencing to 0
    println!("value of z -> {}", *z); // Prints: 'value of z -> 0'
}

fn main(){
    println!(&mut 4);
}

Hello world in rust

YellowCoder — Thu, 14 Mar 2024 18:28:05 +0000

fn main(){
 println!(“Hello, World!”);
}

Forem: YellowCoder

🦀 Axum - Hello World !

Dereferencing Pointer in Rust

Hello world in rust