DEV Community: Rhl

Ownership in Rust for Typescript devs

Rhl — Sat, 28 Sep 2024 16:27:31 +0000

Hi, I am Rahul and I learnt rust to build Loadjitsu.io. This is the fifth post in my series on "Rust for typescript devs".
Read the third part about Functions here.
Read the intro post here.

Basics of ownership in Rust

Ownership is one of the most fundamental and unique concepts in Rust, setting it apart from many other programming languages, including TypeScript. Rust’s ownership model helps ensure memory safety without needing a garbage collector, making it highly efficient while preventing common errors like data races, null pointer dereferencing, or dangling pointers. In this section, we’ll dive deep into the concept of ownership in Rust, explore its key rules, and explain how it works with practical examples.

The Basics of Ownership

In Rust, ownership is the system that manages memory. The main idea is that each value in Rust has a variable that’s its owner, and there can only be one owner at a time. When the owner goes out of scope, Rust automatically deallocates the memory associated with that value.

Here are the three key rules of ownership in Rust:

Each value in Rust has a single owner.
There can only be one owner of a value at a time.
When the owner goes out of scope, the value is automatically dropped.

This ownership system ensures that memory is cleaned up efficiently, without needing a garbage collector or manual memory management, as is required in some other languages like C or C++.

Example of Ownership

Let’s start with a simple example to show ownership in action.


{
    let s = String::from("hello"); // `s` owns the string "hello"
    // We can use `s` here
} // When `s` goes out of scope, "hello" is automatically dropped

In this example:

The String::from("hello") allocates memory on the heap for the string "hello".
The variable s becomes the owner of that memory.
When s goes out of scope (i.e., at the end of the block), Rust automatically calls drop to free the memory.

Ownership ensures that memory is automatically cleaned up when it's no longer needed, which is crucial for writing efficient programs without memory leaks.

Ownership and Moves

In Rust, when you assign a value from one variable to another, the ownership is moved from the original variable to the new one. After the move, the original variable is no longer valid.

Example:


let s1 = String::from("hello");
let s2 = s1; // Ownership of the string moves from `s1` to `s2`
// `s1` is no longer valid here

After s1 is moved to s2, Rust considers s1 to be invalid, and trying to use s1 would result in a compile-time error. This ensures there’s no duplication of ownership, which would lead to memory safety issues.

Why does this happen?

Strings in Rust are stored on the heap, and when you move ownership from one variable to another, the new variable takes control of the heap-allocated data. By invalidating the original variable, Rust avoids potential issues like double frees (where two variables try to free the same memory) or dangling references.

What if You Need to Use the Original Variable?

If you want to continue using the original variable after assigning it to a new one, you can clone the data instead of moving it. Cloning creates a deep copy of the data on the heap, allowing both variables to own independent copies of the data.

Example of Cloning:


let s1 = String::from("hello");
let s2 = s1.clone(); // `s2` is a deep copy of `s1`
// Both `s1` and `s2` are valid here

By using clone, both s1 and s2 are valid and independent of each other. While cloning allows you to retain both variables, it comes with a performance cost, as it involves copying the data.

Ownership and Functions

When passing values to functions, ownership behaves the same way: the function takes ownership of the value, and once the function completes, the value is dropped unless it is returned.

Example of Passing Ownership to a Function:


fn takes_ownership(s: String) {
    println!("{}", s);
} // `s` is dropped here

let s1 = String::from("hello");
takes_ownership(s1); // `s1` is moved to the function and is no longer valid here

In this example:

takes_ownership takes ownership of the string s1.
After the function call, s1 is no longer valid, because its ownership was moved into the function, and it was dropped when the function finished.

Returning Ownership from Functions

If you want to pass ownership back after a function call, you need to return the value. This allows you to transfer ownership between different scopes.

Example of Returning Ownership:


fn takes_and_gives_back(s: String) -> String {
    s // Return ownership back to the caller
}

let s1 = String::from("hello");
let s2 = takes_and_gives_back(s1); // Ownership is moved to `s2`

Here, ownership of s1 is passed to the function and returned back to s2. After this, s1 is invalid, but s2 can be used.

Borrowing and References

Often, you want to let a function use a value without taking ownership. Rust allows this via borrowing. Borrowing allows you to pass references to data without transferring ownership.

Example of Borrowing:


fn borrow_string(s: &String) {
    println!("{}", s);
}

let s1 = String::from("hello");
borrow_string(&s1); // Borrow `s1` without moving ownership
// `s1` is still valid here

In this example, the function borrow_string takes a reference to the string (&String), allowing the function to use the string without taking ownership of it. This means s1 remains valid after the function call.

Mutable Borrowing

If you need to modify the borrowed value, you can use a mutable reference.

Example of Mutable Borrowing:


fn modify_string(s: &mut String) {
    s.push_str(", world");
}

let mut s1 = String::from("hello");
modify_string(&mut s1); // Borrow `s1` mutably
println!("{}", s1); // Output: "hello, world"

Here, modify_string takes a mutable reference (&mut String), allowing it to modify the original string. With mutable references, Rust ensures that you can only have one mutable reference to a value at a time, which prevents data races in concurrent programs.

Rules of Borrowing

There are a few rules to follow when working with references and borrowing in Rust:

You can have either one mutable reference or any number of immutable references, but not both.
References must always be valid. They cannot outlive the value they refer to.

These rules ensure that Rust’s memory safety guarantees are upheld.

Dangling References

Rust prevents dangling references, which occur when a reference points to invalid memory. The borrow checker in Rust ensures that references are always valid by enforcing strict lifetime rules.

Example of a Potential Dangling Reference:


let r;
{
    let s = String::from("hello");
    r = &s; // Error: `s` does not live long enough
}
// `r` would be a dangling reference here

In this case, s goes out of scope at the end of the inner block, making r a dangling reference. Rust’s borrow checker catches this at compile time, preventing the error.

Rust for typescript devs: Functions

Rhl — Mon, 02 Sep 2024 12:49:18 +0000

Hi, I am Rahul and I learnt rust to build Loadjitsu.io. This is the fourth post in my series on "Rust for typescript devs".
Read the third part about Strings here.
Read the intro post here.

Functions are the building blocks of any programming language, allowing you to encapsulate logic and reuse code effectively. As a TypeScript developer, you’re familiar with how functions work, but Rust introduces a few differences in syntax and functionality. In this section, we’ll explore how functions in Rust compare to those in TypeScript, using examples to highlight the similarities and differences.

Basic Function Syntax

TypeScript:

In TypeScript, you define a function using the function keyword, followed by the function name, parameters, and return type. TypeScript’s function syntax is straightforward and familiar to anyone who has worked with JavaScript.


function add(a: number, b: number): number {
    return a + b;
}

Rust:

In Rust, functions are defined using the fn keyword, followed by the function name, parameters, and return type. While the syntax is different, the underlying concept is similar.


fn add(a: i32, b: i32) -> i32 {
    a + b
}

Similarity: Both languages require you to define the function's parameters and return type. In Rust, the return type is specified after an arrow ->, and the last expression in the function is returned by default, without needing a return keyword (although you can use return explicitly if you wish).

Function Parameters and Return Types

TypeScript:

In TypeScript, function parameters and return types are annotated with their types, helping to catch errors at compile time.


function greet(name: string): string {
    return `Hello, ${name}!`;
}

Rust:

Rust also requires you to specify the types of function parameters and return values, ensuring type safety.


fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

Key Difference: Rust's greet function uses &str for the parameter type (a string slice) and String for the return type. This distinction between string slices and owned strings is a key part of Rust’s type system, ensuring efficient memory usage and safety.

Functions Without Return Values

Both TypeScript and Rust allow you to write functions that perform an action without returning a value.

TypeScript:

In TypeScript, such functions are typically annotated with a return type of void.


function logMessage(message: string): void {
    console.log(message);
}

Rust:

In Rust, functions that don’t return a value have a return type of () (the unit type), which is similar to void in TypeScript.


fn log_message(message: &str) {
    println!("{}", message);
}

Similarity: In both languages, you can create functions that perform actions without returning a value. In Rust, the absence of a return type is indicated by the unit type ().

Function Overloading

TypeScript:

TypeScript supports function overloading, allowing you to define multiple signatures for the same function. This is useful when a function can be called with different types or numbers of arguments.


function display(value: string): void;
function display(value: number): void;
function display(value: string | number): void {
    console.log(value);
}

Rust:

Rust does not support traditional function overloading. However, you can achieve similar behavior using traits or enum to handle different types of input.


fn display(value: &str) {
    println!("{}", value);
}

fn display_number(value: i32) {
    println!("{}", value);
}

Key Difference: In Rust, you would typically define separate functions or use traits to handle different types of inputs. While TypeScript’s function overloading allows for more flexible function definitions, Rust’s approach emphasizes clarity and explicitness.

Closures

Both TypeScript and Rust support closures, which are functions defined within another function. Closures can capture variables from their surrounding environment.

TypeScript:

In TypeScript, closures are commonly used with anonymous functions or arrow functions.


function makeAdder(x: number) {
    return function(y: number): number {
        return x + y;
    };
}

const add5 = makeAdder(5);
console.log(add5(10)); // Output: 15

Rust:

In Rust, closures are defined using the || syntax, and they can capture variables from the surrounding scope.


fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

let add5 = make_adder(5);
println!("{}", add5(10)); // Output: 15

Similarity: Both TypeScript and Rust allow you to create closures that capture and use variables from their surrounding environment. In Rust, the move keyword can be used to take ownership of the captured variables.

Higher-Order Functions

Higher-order functions, which take other functions as arguments or return them, are supported in both TypeScript and Rust.

TypeScript:


function applyFunction(f: (x: number) => number, value: number): number {
    return f(value);
}

function square(x: number): number {
    return x * x;
}

console.log(applyFunction(square, 5)); // Output: 25

Rust:


fn apply_function<F>(f: F, value: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(value)
}

fn square(x: i32) -> i32 {
    x * x
}

println!("{}", apply_function(square, 5)); // Output: 25

Similarity: Both languages allow you to pass functions as arguments to other functions. In Rust, the Fn trait is used to define the type of the function argument, ensuring type safety.

Read the next post about ownership in Rust here

Rust for typescript devs part 3 - Strings

Rhl — Sun, 01 Sep 2024 05:19:57 +0000

Hi, I am Rahul and I learnt rust to build Loadjitsu.io. This is the third post in my series on "Rust for typescript devs".
Read the second part about variables and mutability here.
Read the intro post here.

Strings are a fundamental data type in any programming language, allowing you to work with text data. As a TypeScript developer, you're accustomed to using strings in a straightforward manner, with the string type being a key part of the language. In Rust, strings are slightly more complex, offering both string slices and owned strings, each with its specific use cases. In this section, we’ll explore how Rust handles strings and how these concepts relate to what you already know from TypeScript.

String Types in TypeScript and Rust

TypeScript:

In TypeScript, strings are simple and flexible. They are always of the string type, and you can create them using either single or double quotes, or template literals.

let greeting: string = "Hello, world!";
let name: string = `TypeScript Developer`;

Rust:

Rust offers two main types for handling strings: &str (string slices) and String. Each serves a different purpose, providing more control over how memory is managed.

&str (String Slice): This is a reference to a sequence of characters. It’s immutable and does not own the data it points to, similar to a borrowed reference.
String: This is an owned, growable string. It’s mutable and heap-allocated, which means it can be resized and modified.

let greeting: &str = "Hello, world!"; // Immutable, similar to a 'const' string in TypeScript
let mut name: String = String::from("Rust Developer"); // Mutable, similar to a 'let' string in TypeScript

Key Difference: Unlike TypeScript’s string, which is a catch-all type, Rust differentiates between string slices (&str) and owned strings (String). This distinction allows for more efficient memory management and control over how strings are used and modified.

Creating and Modifying Strings

TypeScript:

In TypeScript, strings are immutable. Once created, you cannot change the string itself, but you can create a new string based on the existing one.

let greeting: string = "Hello";
let name: string = "TypeScript Developer";
let message: string = `${greeting}, ${name}!`; // String interpolation

Rust:

Rust strings can be modified, but you must use the String type if you want to change the contents of the string.

let greeting: &str = "Hello";
let mut name: String = String::from("Rust Developer");
name.push_str(" is awesome!"); // Modifying the String
let message = format!("{}, {}!", greeting, name); // String formatting, similar to interpolation

Similarity: Both TypeScript and Rust allow you to create new strings based on existing ones. However, Rust requires you to use the String type if you want to modify the string after it’s created, whereas TypeScript strings remain immutable.

String Slices vs. Owned Strings

Understanding the difference between &str and String is crucial when working with Rust. Here’s how they compare:

String Slices (&str): These are similar to references to strings in TypeScript. They’re lightweight, do not own the data, and are generally more efficient for read-only operations.
```
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

let name = "Rust Developer";
greet(name); // Passing a string slice to a function
```
Owned Strings (String): These are mutable and own the data they contain. If you need to modify or own the string, you’ll use String.
```
let mut name = String::from("Rust Developer");
name.push_str(" is learning Rust!"); // Modifying the string
```

Similarity: In TypeScript, you often pass strings as references without worrying about ownership or mutability. In Rust, you need to be mindful of whether you’re working with a borrowed reference (&str) or an owned, mutable string (String). This distinction is a key part of Rust’s ownership system, which helps prevent memory-related bugs.

Concatenation and Interpolation

Both TypeScript and Rust allow you to concatenate strings and insert variables within strings, but the syntax differs slightly.

TypeScript:


let greeting = "Hello";
let name = "TypeScript Developer";
let message = greeting + ", " + name + "!"; // Concatenation

let interpolatedMessage = `${greeting}, ${name}!`; // Interpolation

Rust:


let greeting = "Hello";
let name = "Rust Developer";
let message = [greeting, ", ", name, "!"].concat(); // Concatenation using an array of string slices

let interpolated_message = format!("{}, {}!", greeting, name); // Interpolation using format!

Key Difference: While TypeScript uses the + operator for concatenation and template literals for interpolation, Rust provides the format! macro for interpolation and typically uses other methods like push_str or array concatenation for joining strings.

Continue to the next post about Functions in rust here

Rust for typescript devs Part 2: Immutabilty

Rhl — Thu, 29 Aug 2024 06:30:11 +0000

Hi, I am Rahul. I learnt rust to build Loadjitsu and this is the second post in my "Rust for typescript devs series".
Read the intro post here

Immutability is a concept that TypeScript developers encounter frequently, especially when dealing with const variables or functional programming patterns. In Rust, immutability is not just a recommendation; it's the default behavior for all variables. This emphasis on immutability is a cornerstone of Rust's design, contributing to its reputation for safety and performance. In this section, we’ll explore how Rust’s approach to immutability compares to what you’re used to in TypeScript and why this concept is so integral to writing reliable Rust code.

Immutability by Default

TypeScript:

In TypeScript, you use the const keyword to declare variables that should not be reassigned. However, if you use let, the variable is mutable by default, meaning its value can be changed after it's been assigned.

typescript

const immutableValue = 10;
// immutableValue = 20; // Error: Assignment to constant variable.

let mutableValue = 10;
mutableValue = 20; // This works just fine.

Rust:

In Rust, all variables are immutable by default. If you want a variable to be mutable, you must explicitly mark it with the mut keyword.

rust


let immutable_value = 10;
// immutable_value = 20; // Error: cannot assign twice to immutable variable

let mut mutable_value = 10;
mutable_value = 20; // This works just fine.

Key Difference:
While TypeScript gives you the option to make variables immutable using const, Rust takes the opposite approach by making all variables immutable unless explicitly stated otherwise with mut. This default immutability reduces the likelihood of unintended side effects, making your code more predictable and easier to reason about.

The Benefits of Immutability

Immutability plays a crucial role in maintaining the integrity of your data and avoiding bugs caused by unintended modifications. This is particularly important in concurrent programming, where multiple threads might access and modify the same data. Rust's emphasis on immutability helps prevent such issues at compile time, ensuring that your code is safe from data races and other concurrency problems.

TypeScript:
In TypeScript, immutability is often encouraged in functional programming patterns or when working with Redux in React, but it’s not enforced by the language.

typescript

const add = (a: number, b: number): number => a + b;

const immutableObject = { name: "Alice" };
// immutableObject.name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property

Rust:
Rust enforces immutability at the language level, making it an integral part of writing safe and efficient code. When you declare a variable without mut, you’re assured that its value will not change, making your code more predictable and less prone to bugs.

rust

fn add(a: i32, b: i32) -> i32 {
    a + b
}

let immutable_object = String::from("Alice");
// immutable_object.push_str("Bob"); // Error: Cannot borrow immutable object as mutable

In Rust, immutability isn’t just a best practice; it’s a default. This default behavior ensures that your variables remain unchanged unless explicitly stated otherwise, leading to safer and more reliable code. This is especially beneficial in concurrent and multi-threaded environments, where mutable shared state can lead to complex and hard-to-debug issues.

Mutability with mut
There are times when you do need to mutate a variable, and Rust allows for this, but only when you explicitly declare your intent by using the mut keyword.

TypeScript:

typescript

let counter = 0;
counter += 1; // This is allowed because 'let' allows reassignment

Rust:

let mut counter = 0;
counter += 1; // This is allowed because 'mut' explicitly allows mutation

Key Difference:

In TypeScript, let variables are mutable by default, whereas in Rust, mutability must be explicitly declared. This explicitness in Rust helps prevent accidental mutations, making the code more transparent and easier to maintain.

Immutability in Function Parameters

Another area where Rust emphasizes immutability is in function parameters. By default, all function parameters in Rust are immutable, which aligns with the language’s general preference for immutability.

TypeScript:

In TypeScript, function parameters are mutable by default, meaning you can change their values within the function body, although it’s generally not a recommended practice.

typescript

function increment(x: number): number {
    x += 1; // This is allowed, but often not recommended
    return x;
}

Rust:

In Rust, if you want to modify a parameter within a function, you need to explicitly pass it as a mutable reference. Otherwise, it remains immutable by default.

rust

fn increment(mut x: i32) -> i32 {
    x += 1;
    x
}

Rust’s immutability by default extends to function parameters, ensuring that you can trust the values passed to functions to remain unchanged unless explicitly declared otherwise. This further reinforces the safety and predictability of your code.

Immutability is more than just a coding practice in Rust; it’s a fundamental aspect of the language’s design. By making variables immutable by default, Rust encourages you to write code that is safer, more predictable, and easier to understand. As a TypeScript developer, you’re already familiar with the concept of immutability, but Rust takes it to the next level by making it the default behavior.

That is it for this blog, in the next blog in the series we are going to look at strings in rust and how they compare with strings in typescript

Continue to part 3 - Strings

An introduction to rust for the typescript developer

Rhl — Tue, 27 Aug 2024 12:41:08 +0000

As a TypeScript developer, you’ve likely become accustomed to the flexibility and safety that TypeScript offers. The language’s ability to catch errors early, combined with its strong typing system, makes it a powerful tool for building scalable web applications. But what if I told you that there’s another language that can take your understanding of systems programming to the next level, with an even stronger focus on safety and performance? That language is Rust.

I first decided to learn Rust to build Loadjitsu, a load testing tool using the Tauri framework. Coming from a TypeScript background, I was pleasantly surprised by how quickly I could adapt to Rust. Despite the differences in syntax and some underlying concepts, I found that my experience with TypeScript provided a solid foundation for grasping Rust’s core principles.

In this post, I’m going to show you how Rust can be your next big leap. I’ll walk you through how being a TypeScript developer actually gives you a head start with Rust, making the learning curve less steep and the rewards even greater. By the end, you’ll see why Rust isn’t just for systems programmers or those seeking maximum performance—it’s for anyone who wants to take their coding skills to the next level. Ready to dive in? Let’s get started.

Numbers in Rust

As a TypeScript developer, you're already familiar with the concept of numbers as a fundamental data type. Numbers are crucial in any programming language, and Rust, like TypeScript, provides a robust system for working with them. However, Rust introduces some additional nuances that give you more control over how numbers are handled in your programs. In this section, we'll dive deep into how Rust manages numeric data types, comparing them to what you already know from TypeScript.

Numeric Types: TypeScript vs. Rust

TypeScript:

In TypeScript, all numbers—whether integers or floating-point—are represented by the number type. This simplicity makes it easy to work with numeric data, but it doesn't provide much control over the specific characteristics of the number, such as its precision or whether it's an integer or floating-point value.




let integer: number = 42;
let float: number = 3.14;

Rust:

Rust, on the other hand, offers a more granular approach by requiring you to specify the exact type of number you're working with. This explicitness allows for better performance optimization and ensures that your code behaves exactly as intended.




let integer: i32 = 42;
let float: f64 = 3.14;

In Rust, you have several numeric types to choose from, categorized into:

Integers: i8, i16, i32, i64, i128, isize for signed integers, and u8, u16, u32, u64, u128, usize for unsigned integers.
Floating-Point Numbers: f32 and f64.

Signed and Unsigned Integers

One of the key distinctions Rust introduces is between signed and unsigned integers. This concept may be new if you're primarily familiar with TypeScript, where such distinctions aren't necessary.

Signed Integers (i8, i16, i32, etc.): These can represent both positive and negative numbers.
Unsigned Integers (u8, u16, u32, etc.): These can only represent non-negative numbers, allowing them to store larger positive values compared to their signed counterparts of the same bit size.




let signed_integer: i32 = -10;
let unsigned_integer: u32 = 10;

Rust's distinction between signed and unsigned integers ensures that you're explicitly aware of the range and behavior of the numbers you're working with, which can prevent certain types of bugs that might slip through in a language like TypeScript.

Floating-Point Numbers

Both TypeScript and Rust handle floating-point numbers, but Rust, once again, requires explicit type declarations to ensure that the level of precision is clear.

TypeScript: All floating-point numbers are of type number.




let pi: number = 3.14159;

Rust: Floating-point numbers can be either f32 (single precision) or f64 (double precision).




let pi: f64 = 3.14159;

The concept of floating-point numbers is similar in both languages. However, Rust's explicitness helps avoid unexpected behavior due to precision issues, which can be crucial in scientific calculations or applications where exact precision is critical.

Numeric Operations

Both TypeScript and Rust allow you to perform standard arithmetic operations on numbers, such as addition, subtraction, multiplication, and division.

TypeScript:



let sum = 5 + 10;
let difference = 15 - 5;
let product = 2 * 3;
let quotient = 10 / 2;

Rust:



let sum = 5 + 10;
let difference = 15 - 5;
let product = 2 * 3;
let quotient = 10 / 2;

Arithmetic operations work nearly identically in both TypeScript and Rust. If you're comfortable with basic math in TypeScript, you'll find it easy to transfer those skills to Rust.

Overflow and Underflow

One area where Rust introduces a more rigorous approach is in handling numeric overflow and underflow. Rust’s strict rules help prevent the kind of errors that can occur in TypeScript when a number exceeds the maximum value that can be represented by a given type.

TypeScript: JavaScript’s number type (which TypeScript is based on) can represent values up to Number.MAX_SAFE_INTEGER. However, if a number exceeds this value, it may result in unexpected behavior without any warning.
Rust: Rust will panic in debug mode if an integer overflows, helping you catch potential issues during development. In release mode, Rust performs two’s complement wrapping by default, but you can opt for other behaviors (like saturating arithmetic) if needed.



let max_u8 = u8::MAX;
let overflow = max_u8 + 1; // This will panic in debug mode

Rust’s strict handling of overflow and underflow ensures greater safety and predictability, which is particularly important in systems programming or applications where numerical accuracy is crucial.

That is it for now, in the next blog in this series, we will talk of mutability and immutabilty in rust.

Read the next post in this series "Rust for typescript devs"
Immutabilty