Open in app

Sign in

Write

Sign in

Advanced Rust interview questions — Part 2

Mayank C
Tech Tonic

--

In this series, we are looking into advanced Rust interview questions, 10 at a time. This is the second part, which covers questions 11 to 20. The other parts are:

Question 11 — Explain the concept of advanced pattern matching with lifetimes and generics. How can they be used for powerful data extraction and validation across complex data structures?

Pattern matching with lifetimes

Lifetimes in Rust track the lifetime (borrowing scope) of references. They ensure that borrowed data is valid for the entire duration of its usage within a pattern match. By specifying lifetimes in patterns, you can enforce borrowing rules and prevent dangling references.

Example — Matching by reference lifetime

fn print_slice<'a>(data: &'a [i32]) {
  for element in data {
    println!("{}", element);
  }
}

fn main() {
  let numbers = vec![1, 2, 3, 4, 5];
  print_slice(&numbers);  // Lifetime 'a refers to the lifetime of numbers
}

In this example, the print_slice function takes a slice with a lifetime parameter 'a. This ensures that the borrowed data (&[i32]) is valid for the entire execution of the function, preventing dangling references.

Pattern matching with generics

Generics allow defining functions or data structures that work with various data types. Pattern matching can be combined with generics to handle different types within the same pattern.

Example — Matching on generic option

fn process_value<T>(value: Option<T>) {
  match value {
    Some(x) => println!("Value: {}", x),
    None => println!("No value present"),
  }
}

fn main() {
  let some_value = Some(5);
  let no_value: Option<i32> = None;
  process_value(some_value);
  process_value(no_value);
}

The process_value function is generic over type T. The pattern match within it can handle both Some(x) (where x can be any type) and None.

Advanced pattern matching techniques:

  • Nested struct/enum matching: You can deconstruct nested structures or enums layer by layer within patterns for deep data extraction.
  • Guards: Conditions can be placed within patterns to filter matches based on additional criteria beyond the structure itself.

Example — Nested struct matching with guards

struct Point {
  x: i32,
  y: i32,
}

fn is_positive(x: i32) -> bool {
  x > 0
}

fn main() {
  let point = Point { x: 2, y: -3 };
  match point {
    Point { x, y if is_positive(y) } => println!("Point in first quadrant (x: {}, y: {})", x, y),
    _ => println!("Point not in first quadrant"),
  }
}

Benefits of combining lifetimes and generics with pattern matching

  • Improved readability: Complex data manipulation logic becomes more concise and easier to understand with clear pattern matching conditions.
  • Type safety: Generics ensure type safety by checking for compatible types at compile time.
  • Data validation: Guards within patterns allow for conditional matching, enabling you to validate data during the pattern matching process.
  • Flexibility: This combination allows for handling various data structures and types within the same pattern-based approach.

Question 12 — Describe the usage of advanced async/await features in Rust, such as async/await within closures, concurrency with channels (async/await with channels), and cancellation mechanisms. How can these features be used to build complex asynchronous applications efficiently?

Async/Await within closures

You can use async closures to define code blocks that can be awaited. This allows for creating asynchronous operations within closures without introducing additional future types.

use std::fs::read_to_string;

async fn read_file_async(filename: &str) -> Result<String, std::io::Error> {
  let content = read_to_string(filename).await?;
  Ok(content)
}

let read_file = || async { read_file_async("data.txt").await };

fn main() {
  let fut = read_file();
  // ... other code
  let content = fut.await.unwrap();
  println!("File content: {}", content);
}

Concurrency with channels (async/await with channels)

Channels can be used for communication between asynchronous tasks. You can use async versions of send and recv methods to safely send and receive data concurrently.

use std::sync::mpsc;

async fn producer(tx: mpsc::Sender<i32>) {
  for i in 0..10 {
    tx.send(i).await.unwrap();
  }
}

async fn consumer(rx: mpsc::Receiver<i32>) {
  while let Some(value) = rx.recv().await {
    println!("Received: {}", value);
  }
}

fn main() {
  let (tx, rx) = mpsc::channel();
  let producer_task = tokio::spawn(producer(tx.clone()));
  let consumer_task = tokio::spawn(consumer(rx));
  tokio::join!(producer_task, consumer_task);
}

Cancellation mechanisms

Rust provides mechanisms for cancelling asynchronous tasks before they complete. This allows for handling graceful shutdowns or timeouts within asynchronous applications.

use tokio::task;

async fn long_running_task() -> Result<(), std::io::Error> {
  // Simulate long-running operation
  std::thread::sleep(std::time::Duration::from_secs(5));
  Ok(())
}

fn main() {
  let task = tokio::spawn(long_running_task());
  // ... some logic
  if should_cancel {
    task.abort();
  }
  // ... await the task (optional)
}

Benefits of these features

  • Improved readability: Async closures and async methods with channels provide a cleaner syntax for writing asynchronous code.
  • Efficient concurrency: Channels facilitate communication and data exchange between concurrent asynchronous tasks.
  • Graceful handling: Cancellation mechanisms allow for controlled termination of tasks, improving application robustness.

Building asynchronous applications

  • Combine these features with libraries like tokio for managing asynchronous tasks and runtime execution.
  • Utilize pattern matching and destructuring to handle different outcomes of asynchronous operations within async blocks.
  • Design your application with clear separation of concerns, isolating asynchronous logic for better maintainability.

Question 13 — Explain the concept of advanced memory management with arenas in Rust. How can arenas be used for efficient memory allocation and deallocation within a specific scope, potentially improving performance for certain use cases?

Arenas are a type of custom allocator that manages a single block of memory. They offer a more controlled approach to memory allocation compared to the standard Rust allocator. Unlike the standard allocator, arenas typically don’t support deallocation of individual objects while the arena itself is still active.

The benefits of using arenas are:

  • Performance: By avoiding scattered allocations and deallocations, arenas can potentially improve performance, especially for short-lived objects allocated frequently within a specific scope.
  • Reduced fragmentation: Memory fragmentation is less likely with arenas as allocations happen sequentially within the reserved block.

Use cases for arenas

  • Game development: Arenas are often used in game development for managing temporary objects like entities or game state within a frame or level.
  • Parsing/Lexing: Temporary data structures during parsing or lexing operations can benefit from arena allocation for efficiency.
  • Embedded systems: In resource-constrained environments, arenas offer predictable memory usage patterns.

Example using rustc_arena library

use rustc_arena::Arena;

fn main() {
  let mut arena = Arena::new();
  let string1 = arena.alloc("Hello"); // Allocate string within arena
  let string2 = arena.alloc(", ");   // Allocate another string
  let combined_string = format!("{}{}", string1, string2);
  println!("{}", combined_string);

  // Arena goes out of scope here, deallocating all allocated memory
}

Important considerations

  • Arenas are not a replacement for the standard allocator. Use them strategically for specific use cases where the trade-offs are beneficial.
  • While arenas improve allocation performance, they might introduce additional overhead for bookkeeping compared to the standard allocator.
  • Ensure proper scope management of the arena to avoid memory leaks, as deallocation typically happens when the arena goes out of scope.

Advanced arena techniques

  • TypedArenas: Libraries like memoffset offer typed arenas that restrict the types of data allowed within the arena, improving type safety.
  • Custom allocators: You can implement custom allocators that use arenas internally for specific allocation strategies.

Question 14 — Describe how to implement advanced error handling with custom error types that implement specific traits (e.g., From, Display). How can these techniques improve error handling clarity and composability?

Custom error types and traits

  • Define your own error types using enums with variants representing different error scenarios.
  • Implement relevant traits on your error types for enhanced functionality.

Common traits for custom errors

  • From<T>: Allows conversion from another type (T) into your custom error type.
  • Display: Enables displaying the error message using println! or other formatting methods.
  • Debug: Provides a more detailed debug representation of the error for debugging purposes.

An example is shown below:

use thiserror::Error;

#[derive(Error, Debug)]
pub enum MyError {
  IoError(std::io::Error),
  InvalidInput(String),
  // Add more variants for specific errors
}

impl From<std::io::Error> for MyError {
  fn from(err: std::io::Error) -> Self {
    MyError::IoError(err)
  }
}

impl std::fmt::Display for MyError {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "Error: {}", match self {
      MyError::IoError(err) => err.to_string(),
      MyError::InvalidInput(msg) => format!("Invalid input: {}", msg),
    })
  }
}

Improved error handling clarity:

  • Custom error types with specific variants provide clear and informative messages about the encountered error.
  • Implementing Display allows for user-friendly error messages that explain the nature of the error.

An example is shown below:

fn read_file(filename: &str) -> Result<String, MyError> {
  let mut data = String::new();
  let mut file = std::fs::File::open(filename)?;
  std::io::read_to_string(&mut file, &mut data)?;
  Ok(data)
}

fn process_data(data: &str) -> Result<(), MyError> {
  // ... process data
  Ok(())
}

fn main() -> Result<(), MyError> {
  let result = process_data(&read_file("data.txt")?);
  match result {
    Ok(_) => println!("Data processed successfully!"),
    Err(err) => println!("Error: {}", err),
  }
  Ok(())
}

Error handling composable

  • Implementing From<T> allows for automatic conversion from other error types into your custom error type.
  • This simplifies error handling by enabling chaining operations that might return different error types.

An example is:

fn download_data(url: &str) -> Result<Vec<u8>, MyError> {
  use reqwest::Error;
  let response = reqwest::get(url)?;
  let data = response.bytes().map(|result| result.unwrap())
                         .collect::<Vec<u8>>();
  Ok(data)
}

fn main() -> Result<(), MyError> {
  let data = download_data("https://example.com/data.txt")?;
  // ... process data
  Ok(())
}

Benefits

  • Clarity: More informative error messages improve debugging and user experience.
  • Composability: Chaining operations with different error types becomes easier with automatic conversion.
  • Flexibility: You can define custom error types and behavior based on your specific needs.

Question 15 — Explain the concept of advanced generics with associated items (traits) and where clauses. How can these features be used to create highly generic abstractions with specific requirements for implementing types?

Generics with associated items (Traits)

Generics allow functions or data structures to work with various types. Associated items (traits) define additional requirements that concrete types implementing the generic type must fulfill. An example is as follows:

trait Printable {
  fn format(&self) -> String;
}

struct Point<T> {
  x: T,
  y: T,
}

impl<T: Printable> Point<T> {
  fn print(&self) -> String {
    format!("({}, {})", self.x.format(), self.y.format())
  }
}

impl Printable for i32 {
  fn format(&self) -> String {
    self.to_string()
  }
}

fn main() {
  let point = Point { x: 5, y: 10 };
  let output = point.print();
  println!("{}", output);
}

In this example, the Point struct is generic over a type T. However, T must also implement the Printable trait, which ensures that any type used with Point can be formatted into a string.

Where clauses

Where clauses define additional constraints on the generic type parameters. They allow specifying requirements beyond just being a specific type.

fn largest<T>(arr: &[T]) -> Option<&T>
where T: Ord { // Restrict T to implement the Ord trait (for ordering)
  arr.iter().max()
}

fn main() {
  let numbers = vec![1, 3, 2];
  let largest_number = largest(&numbers);
  match largest_number {
    Some(num) => println!("Largest number: {}", num),
    None => println!("Empty array"),
  }
}

The largest function is generic over T, but it has a where clause requiring T to implement the Ord trait (for ordering). This ensures that only types that can be compared for ordering can be used with this function.

Benefits of these features

  • Improved code reusability: You can create generic functions/data structures with specific requirements, promoting code reuse across different types.
  • Type safety: Associated items and where clauses enforce compile-time checks, ensuring that types used with generics meet the required functionalities.
  • Flexibility: You can define complex abstractions with varying requirements for implementing types.

Generics with associated items and where clauses are powerful tools for creating highly generic abstractions with specific requirements in Rust. By defining traits as associated items and using where clauses, you can ensure that only types with the necessary functionalities can be used within your generic code.

Question 16 — Describe the role of libraries like parking_lot or crossbeam for advanced concurrency tasks in Rust. How can these libraries help with complex synchronization mechanisms or thread pool management?

Here’s a breakdown of the roles of parking_lot and crossbeam libraries for advanced concurrency tasks in Rust, focusing on complex synchronization and thread pool management:

parking_lot library:

  • Provides lightweight synchronization primitives like mutexes, condition variables, and spinlocks.
  • Offers smaller and often faster alternatives to the standard library’s synchronization types, suitable for fine-grained control.
  • Useful for building low-level synchronization mechanisms for specific use cases.
use parking_lot::Mutex;

let mut data = Mutex::new(5);

{
  let mut locked_data = data.lock();
  *locked_data += 1;
}

println!("Data: {}", *data); // Output: Data: 6

crossbeam library

  • Offers a wider range of tools for concurrency like channels, thread pools, and atomic operations.
  • Provides higher-level abstractions for communication and synchronization between threads.
  • Useful for building more complex concurrent applications with efficient data exchange and task management.

Channels

  • Channels enable communication between threads by sending and receiving data.
  • crossbeam::channel provides various channel types for different communication patterns.
use crossbeam::channel;

fn producer(tx: channel::Sender<i32>) {
  for i in 0..10 {
    tx.send(i).unwrap();
  }
}

fn consumer(rx: channel::Receiver<i32>) {
  while let Ok(val) = rx.recv() {
    println!("Received: {}", val);
  }
}

fn main() {
  let (tx, rx) = channel::bounded(10);
  let producer_thread = std::thread::spawn(|| producer(tx.clone()));
  let consumer_thread = std::thread::spawn(|| consumer(rx));
  producer_thread.join().unwrap();
  consumer_thread.join().unwrap();
}

Thread pools

  • Thread pools manage a pool of worker threads for executing tasks concurrently.
  • crossbeam::thread simplifies creating and managing thread pools.
use crossbeam::thread;

fn do_work(data: i32) -> i32 {
  data * 2
}

fn main() {
  let pool = thread::ThreadPool::new(4);
  let tasks = vec![1, 2, 3, 4].into_iter().map(|num| {
    pool.spawn(move || do_work(num))
  });

  let results: Vec<i32> = tasks.into_iter().map(|future| future.join().unwrap())
                               .collect();

  println!("Results: {:?}", results); // Output: Results: [2, 4, 6, 8]
}

Choosing between libraries

  • Use parking_lot for low-level, fine-grained synchronization needs where performance is critical.
  • Use crossbeam for higher-level concurrency patterns with channels, thread pools, and atomic operations for more complex scenarios.

Question 17 — Explain the concept of advanced optimization techniques in Rust beyond basic memory management. How can techniques like inlining functions, loop unrolling, and auto-vectorization be used to further optimize code performance?

Advanced optimization techniques like inlining functions, loop unrolling, and auto-vectorization can potentially improve performance in Rust. Let’s take a look at each technique.

Inlining functions

Inlining involves copying the body of a function directly at the call site, eliminating the function call overhead. This can improve performance for small, frequently called functions.

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

fn main() {
  let result = add(5, 3); // Potential inlining candidate
  println!("Sum: {}", result);
}

The compiler might decide to inline the add function for this specific call, reducing the function call overhead.

Loop unrolling

Unrolling duplicates the loop body a certain number of times, potentially improving performance by reducing loop control overhead. Use this technique cautiously as it can increase code size and might not always benefit performance on modern processors.

fn sum_array(data: &[i32]) -> i32 {
  let mut sum = 0;
  for i in 0..data.len() {
    sum += data[i];
  }
  sum
}

// Unrolled version (manually)
fn sum_array_unrolled(data: &[i32]) -> i32 {
  let mut sum = 0;
  for i in 0..data.len() {
    sum += data[i];
    if i + 1 < data.len() {
      sum += data[i + 1];
    }
    if i + 2 < data.len() {
      sum += data[i + 2];
    }
    // ... (unroll further if needed)
  }
  sum
}

fn main() {
  let numbers = vec![1, 2, 3, 4, 5];
  let sum = sum_array(&numbers);
  // ...
}

Auto-Vectorization

Modern compilers can automatically vectorize loops, meaning they translate the loop operations to use SIMD (Single Instruction, Multiple Data) instructions for parallel execution on multiple cores.

fn add_arrays(a: &[f32], b: &[f32]) -> Vec<f32> {
  let mut result = Vec::with_capacity(a.len());
  for i in 0..a.len() {
    result.push(a[i] + b[i]);
  }
  result
}

fn main() {
  let a = vec![1.0, 2.0, 3.0, 4.0];
  let b = vec![5.0, 6.0, 7.0, 8.0];
  let sum = add_arrays(&a, &b);
  // ...
}

The compiler might automatically vectorize the loop in add_arrays to perform element-wise addition on multiple data elements simultaneously.

Important considerations

  • These optimizations are compiler-dependent and might not always be applied automatically.
  • Profile your application to identify bottlenecks and determine if these optimizations are beneficial.
  • Overly aggressive optimization can make code harder to read and maintain. Use them judiciously after profiling.

Advanced optimization techniques like these can potentially improve performance in Rust. However, it’s crucial to understand their trade-offs, profile your application to identify bottlenecks, and prioritize code readability and maintainability alongside performance gains. Consider using tools like cargo build --release to enable compiler optimizations during the build process.

Question 18 — Explain the concept of advanced async/await features in Rust, such as using async/await with streams (Stream<T>) and futures (Future) for handling asynchronous data pipelines efficiently.

Advanced async/await features in Rust, combined with streams and futures, empowers us to build efficient asynchronous data pipelines. Streams provide a way to produce values asynchronously, while futures represent pending computations. By chaining these elements with async/await, we can create readable and performant asynchronous code that processes data as it becomes available.

Async/Await with streams (Stream<T>)

Streams are iterators that produce values asynchronously. We can use async/await within a stream implementation to define how values are yielded asynchronously.

use std::pin::Pin;
use std::task::{Context, Poll};
use futures::stream::{Stream, StreamExt};

struct NumberStream {
  count: i32,
  max: i32,
}

impl Stream for NumberStream {
  type Item = i32;

  fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
    if self.count <= self.max {
      let value = self.count;
      self.count += 1;
      Poll::Ready(Some(value))
    } else {
      Poll::Ready(None)
    }
  }
}

async fn generate_numbers(max: i32) -> impl Stream<Item = i32> {
  NumberStream { count: 0, max }
}

fn main() {
  let mut stream = generate_numbers(5);
  while let Some(num) = stream.next().await {
    println!("Number: {}", num);
  }
}

Async/Await with futures (Future)

Futures represent computations that might not complete immediately. We can use async/await to chain asynchronous operations using futures.

async fn download_data(url: &str) -> Result<Vec<u8>, reqwest::Error> {
  let response = reqwest::get(url).await?;
  let data = response.bytes().map(|result| result.unwrap())
                         .collect::<Vec<u8>>();
  Ok(data)
}

fn main() {
  async fn process_data(data: Vec<u8>) {
    // ... process data
  }

  let fut = download_data("https://example.com/data.txt");
  let data = fut.await.unwrap();
  process_data(data).await;
}

Combining streams and futures for async pipelines

We can chain asynchronous operations involving streams and futures using async/await. This allows us to process data asynchronously as it becomes available from a stream.

use futures::stream::futures_unordered::FuturesUnordered;
use futures::Stream;

async fn download_and_process_data(urls: Vec<&str>) -> Vec<Result<String, reqwest::Error>> {
  let mut futures = FuturesUnordered::new();
  for url in urls {
    futures.push(async move {
      let data = download_data(url).await?;
      // Process data and return result
      Ok(String::from_utf8(data)?)
    });
  }
  futures.collect().await
}

fn main() {
  let urls = vec!["https://example.com/data1.txt", "https://example.com/data2.txt"];
  let results = download_and_process_data(urls).await;
  // Handle results
}

In this example, download_and_process_data downloads data from multiple URLs concurrently using a stream of futures and collects the results.

Benefits

  • Improved readability: async/await makes asynchronous code more readable and sequential-like.
  • Efficient data pipelines: We can create efficient asynchronous data pipelines by chaining streams and futures.
  • Flexibility: This approach allows for handling various asynchronous data sources and processing steps.

Question 19 — Describe the role of libraries like tokio or async-std for building highly scalable and performant asynchronous applications in Rust. How do these libraries simplify working with concurrency and asynchronous tasks?

Libraries like tokio and async-std provide crucial tools for building asynchronous applications in Rust. Tokio offers a feature-rich runtime for demanding use cases, while async-std prioritizes simplicity and portability. Let’s take a brief look at both of them.

Tokio

Tokio is a popular asynchronous runtime for Rust, offering a comprehensive set of tools for managing concurrency and asynchronous tasks. It provides features like a multi-threaded executor, channels for communication, timers, and abstractions for network I/O. The benefits of using tokio are:

  • Scalability: Handles a large number of concurrent tasks efficiently using a thread pool and efficient scheduling.
  • Performance: Optimized for low-level I/O operations, leading to performant asynchronous applications.
  • Rich ecosystem: Extensive ecosystem of libraries built on top of tokio for various functionalities.

Here is an example of simple tokio task with timer:

use tokio::time::{sleep, Duration};
use tokio::task;

async fn delayed_print(msg: &str, delay: Duration) {
  sleep(delay).await;
  println!("{}", msg);
}

fn main() {
  let task1 = task::spawn(delayed_print("Hello", Duration::from_secs(1)));
  let task2 = task::spawn(delayed_print("World", Duration::from_secs(2)));
  tokio::join!(task1, task2);
}

async-std

Async-std is a lightweight alternative to tokio with a focus on simplicity and portability. This library offers basic abstractions for asynchronous programming like async/await, futures, and channels. Async-std is well-suited for smaller applications or embedded systems where complexity needs to be minimized. The benefits of using async-std are:

  • Simplicity: Easy to learn and use with a smaller API compared to tokio.
  • Portability: Works across different platforms, including bare-metal environments.
  • Lightweight: Smaller footprint compared to tokio, making it suitable for resource-constrained systems.

Here is an example of simple async-std task with timer:

use async_std::task;
use async_std::future::timeout;
use std::time::Duration;

async fn delayed_print(msg: &str, delay: Duration) {
  timeout(delay, async { println!("{}", msg) }).await.unwrap();
}

fn main() {
  let task1 = task::spawn(delayed_print("Hello", Duration::from_secs(1)));
  let task2 = task::spawn(delayed_print("World", Duration::from_secs(2)));
  async_std::task::join!(task1, task2);
}

Choosing between libraries

  • Use tokio for large-scale, highly concurrent applications where performance and scalability are critical.
  • Use async-std for smaller projects, embedded systems, or when simplicity and portability are priorities.

Question 20 — Explain the concept of advanced ownership transfer with PhantomData<T>. How is it used for metadata associated with a type without actually owning the data itself? Discuss use cases and potential limitations.

PhantomData<T> is a powerful tool for advanced ownership management in Rust. It allows us to associate metadata with types without actual data ownership, enabling interesting use cases for generic data structures and static checks. However, understand the limitations and consider if simpler solutions might be more appropriate for our specific needs.

Concept of PhantomData<T>

PhantomData<T> is a zero-sized marker type used to associate metadata with a type without actually storing or owning the data of type T. It acts as a placeholder within a struct or function, indicating that the type exists, but not requiring an instance of T to be allocated.

Use cases for PhantomData<T>

There are some interesting use cases of PhantomData:

Generic data structures with associated metadata

We can use PhantomData<T> to store information about the type of data a generic struct holds without affecting its size or requiring ownership of the data itself. Here is an example of generic list with length marker:

struct MyList<T> {
  data: Vec<T>,
  _marker: PhantomData<usize>, // Marker for potential length information
}

impl<T> MyList<T> {
  fn len(&self) -> usize {
    self.data.len() // Access actual data for length calculation
  }
}

fn main() {
  let list = MyList { data: vec![1, 2, 3], _marker: PhantomData };
  println!("List length: {}", list.len());
}

In this example, PhantomData<usize> acts as a marker within myList indicating potential length information. However, it doesn't store the actual length. The len method accesses the underlying data to calculate the length.

Static checks and trait bounds

We can also use PhantomData<T> with trait bounds to enforce specific requirements on the types used with a generic struct or function. Here is a example of enforcing send/sync bounds:

use std::sync::{Send, Sync};

struct SharedList<T: Send + Sync> {
  data: Vec<T>,
  _marker: PhantomData<T>,
}

fn main() {
  // This would compile because T is guaranteed to be Send and Sync
  let shared_list = SharedList { data: vec![1, 2, 3], _marker: PhantomData };
}

Here, PhantomData<T> enforces that T must implement both Send and Sync traits, ensuring thread-safety for the SharedList.

Limitations of PhantomData<T>

  • Limited functionality: It cannot access or manipulate the data of type T.
  • Increased code complexity: Can add complexity to the code compared to simpler solutions without generics.
  • Not a replacement for ownership: It doesn’t replace ownership rules in Rust. You still need to manage ownership of the actual data separately.

That’s all about the second part. The other parts are:

Thanks for reading! I hope this would have helped you in some way.

--

--

Mayank C
Tech Tonic

Written by Mayank C

9.4K Followers
Editor for

800 medium articles